Add ImportLocation to SymbolToken

IonDotnet.Tests/Common/SymTabUtils.cs

@@ -22,11 +22,11 @@ internal static void AssertSymbolInTable(string text, int sid, bool duplicate, I
 
             Assert.AreEqual(sid, symbolTable.FindSymbolId(text));
             var token = symbolTable.Find(text);
-            Assert.AreEqual(sid, token.Sid);
+            Assert.AreEqual(SymbolToken.UnknownSid, token.Sid);
             Assert.AreEqual(text, token.Text);
 
             token = symbolTable.Intern(text);
-            Assert.AreEqual(sid, token.Sid);
+            Assert.AreEqual(SymbolToken.UnknownSid, token.Sid);
             Assert.AreEqual(text, token.Text);
         }
     }

IonDotnet.Tests/Internals/ImportLocationTest.cs

@@ -0,0 +1,48 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace IonDotnet.Tests.Internals
+{
+    [TestClass]
+    public class ImportLocationTest
+    {
+        [TestMethod]
+        public void Init_SidAndTextUnknown()
+        {
+            var location = new ImportLocation();
+            Assert.AreEqual(null, location.ImportName);
+            Assert.AreEqual(0, location.Sid);
+        }
+
+        [TestMethod]
+        [DataRow("text1", 123, "text1", 123)]
+        [DataRow("text2", 456, "text2", 456)]
+        public void Bool_EqualsOperator(string text1, int sid1, string text2, int sid2)
+        {
+            var location1 = new ImportLocation(text1, sid1);
+            var location2 = new ImportLocation(text2, sid2);
+            Assert.IsTrue(location1 == location2);
+        }
+
+        [TestMethod]
+        [DataRow("text1", 123, "text1", 456)]
+        [DataRow("text2", 456, "text3", 456)]
+        public void Bool_NotEqualsOperator(string text1, int sid1, string text2, int sid2)
+        {
+            var location1 = new ImportLocation(text1, sid1);
+            var location2 = new ImportLocation(text2, sid2);
+            Assert.IsTrue(location1 != location2);
+        }
+
+        [TestMethod]
+        public void EqualsMethod()
+        {
+            var location = CreateSampleToken();
+            var equalLocation = new ImportLocation("yo", 30);
+            var unEqualLocation = new ImportLocation("yo", 31);
+            Assert.IsTrue(location.Equals(equalLocation));
+            Assert.IsFalse(location.Equals(unEqualLocation));
+        }
+
+        private static ImportLocation CreateSampleToken() => new ImportLocation("yo", 30);
+    }
+}

IonDotnet.Tests/Internals/ReaderLocalTableTest.cs

@@ -15,7 +15,7 @@ void assertTable(ISymbolTable tab, params (string sym, int id)[] syms)
                 {
                     var symtok = tab.Find(sym.sym);
                     Assert.AreEqual(sym, sym, symtok.Text);
-                    Assert.AreEqual(sym.id, symtok.Sid);
+                    Assert.AreEqual(SymbolToken.UnknownSid, symtok.Sid);
                     var symText = tab.FindKnownSymbol(sym.id);
                     Assert.AreEqual(sym.sym, symText);
                     var sid = tab.FindSymbolId(sym.sym);

IonDotnet.Tests/Internals/SharedSymbolTableTest.cs

@@ -45,7 +45,7 @@ public void InternKnownText_KeepEntry(string text)
 
             //make sure that no extra allocation is made
             Assert.AreSame(text, symtok.Text);
-            Assert.AreEqual(1, symtok.Sid);
+            Assert.AreEqual(SymbolToken.UnknownSid, symtok.Sid);
         }
 
         [TestMethod]

IonDotnet.Tests/Internals/SymbolTokenTest.cs

@@ -15,6 +15,46 @@ public void Init_SidAndTextUnknown()
             Assert.AreEqual(token, SymbolToken.None);
         }
 
+        [TestMethod]
+        [DataRow("text1", 123, "text1", 123)]
+        [DataRow("text2", 456, "text2", 456)]
+        public void Bool_EqualsOperator(string text1, int sid1, string text2, int sid2)
+        {
+            var token1 = new SymbolToken(text1, sid1);
+            var token2 = new SymbolToken(text2, sid2);
+            Assert.IsTrue(token1 == token2);
+        }
+
+        [TestMethod]
+        [DataRow("text1", 123, "text1", 456)]
+        [DataRow("text2", 456, "text3", 456)]
+        public void Bool_NotEqualsOperator(string text1, int sid1, string text2, int sid2)
+        {
+            var token1 = new SymbolToken(text1, sid1);
+            var token2 = new SymbolToken(text2, sid2);
+            Assert.IsTrue(token1 != token2);
+        }
+
+        [TestMethod]
+        public void EqualsMethod()
+        {
+            var token = CreateSampleToken();
+            var equalToken = new SymbolToken("yo", 30);
+            var unEqualToken = new SymbolToken("yo", 31);
+            Assert.IsTrue(token.Equals(equalToken));
+            Assert.IsFalse(token.Equals(unEqualToken));
+        }
+
+        [TestMethod]
+        public void IsEquivalentTo()
+        {
+            var token = CreateSampleTokenWithImportLocation();
+            var equalToken = new SymbolToken("yo", 30, new ImportLocation("hey", 40));
+            var unEqualToken = new SymbolToken("oy", 30, new ImportLocation("hey", 41));
+            Assert.IsTrue(token.IsEquivalentTo(equalToken));
+            Assert.IsFalse(token.IsEquivalentTo(unEqualToken));
+        }
+
         [TestMethod]
         [DataRow(0)]
         [DataRow(1)]
@@ -58,5 +98,6 @@ public void ArrayResize_RemainderSetToDefault(int oldLength, int newLength)
         }
 
         private static SymbolToken CreateSampleToken() => new SymbolToken("yo", 30);
+        private static SymbolToken CreateSampleTokenWithImportLocation() => new SymbolToken("yo", 30, new ImportLocation("hey", 40));
     }
 }

IonDotnet/ImportLocation.cs

@@ -0,0 +1,49 @@
+namespace IonDotnet
+{
+    public readonly struct ImportLocation
+    {
+
+        /// <summary>
+        /// The default ImportName, which is unknown
+        /// </summary>
+        public const string UnknownImportName = default;
+
+        /// <summary>
+        /// The default value, corresponds to not_found/unknown
+        /// </summary>
+        public static readonly ImportLocation None = default;
+
+        /// <summary>
+        /// The import name of this import location.
+        /// </summary>
+        public readonly string ImportName;
+
+        /// <summary>
+        /// The ID of this import location.
+        /// </summary>
+        public readonly int Sid;
+
+        /// <summary>
+        /// Create a new ImportLocation struct.
+        /// </summary>
+        /// <param name="importName">ImportName</param>
+        /// <param name="sid">Sid</param>
+        public ImportLocation(string importName, int sid)
+        {
+            ImportName = importName;
+            Sid = sid;
+        }
+
+        public override string ToString() => $"ImportLocation::{{importName:{ImportName}, id:{Sid}}}";
+
+        public static bool operator ==(ImportLocation x, ImportLocation y) => x.ImportName == y.ImportName && x.Sid == y.Sid;
+
+        public static bool operator !=(ImportLocation x, ImportLocation y) => !(x == y);
+
+        public override bool Equals(object that) => that is ImportLocation token && Equals(token);
+
+        public bool Equals(ImportLocation other) => this == other;
+
+        public override int GetHashCode() => ImportName?.GetHashCode() ?? Sid;
+    }
+}

IonDotnet/Internals/Binary/ManagedBinaryWriter.cs

@@ -529,10 +529,10 @@ public override SymbolToken Find(string text)
                 if (text == null) throw new ArgumentNullException(nameof(text));
 
                 var found = _writer._importContext.TryGetValue(text, out var sid);
-                if (found) return new SymbolToken(text, sid);
+                if (found) return new SymbolToken(text, SymbolToken.UnknownSid);
                 found = _writer._locals.TryGetValue(text, out sid);
 
-                return found ? new SymbolToken(text, sid) : default;
+                return found ? new SymbolToken(text, SymbolToken.UnknownSid) : default;
             }
 
             public override string FindKnownSymbol(int sid)

IonDotnet/Internals/ReaderLocalTable.cs

@@ -60,19 +60,17 @@ internal void Refresh()
 
         public SymbolToken Find(string text)
         {
-            var offset = 0;
             foreach (var import in Imports)
             {
                 var t = import.Find(text);
                 if (t != default)
-                    return new SymbolToken(t.Text, offset + t.Sid);
-                offset += import.MaxId;
+                    return new SymbolToken(t.Text, SymbolToken.UnknownSid);
             }
 
             for (var i = 0; i < _ownSymbols.Count; i++)
             {
                 if (_ownSymbols[i] == text)
-                    return new SymbolToken(text, i + 1 + _importedMaxId);
+                    return new SymbolToken(text, SymbolToken.UnknownSid);
             }
 
             return default;

IonDotnet/Internals/SharedSymbolTable.cs

@@ -110,7 +110,7 @@ public SymbolToken Find(string text)
                 return default;
 
             var internedText = _symbolNames[sid - 1];
-            return new SymbolToken(internedText, sid);
+            return new SymbolToken(internedText, SymbolToken.UnknownSid);
         }
 
         public int FindSymbolId(string name)

IonDotnet/Internals/Text/RawTextReader.cs

@@ -487,7 +487,7 @@ private SymbolToken ParseSymbolToken(StringBuilder sb, int token)
                     break;
             }
 
-            return new SymbolToken(text, sid);
+            return new SymbolToken(text, sid, new ImportLocation(GetSymbolTable().Name, sid));
         }
 
         private void FinishValue()
@@ -696,16 +696,16 @@ public IEnumerable<SymbolToken> GetTypeAnnotations()
 
             foreach (var a in _annotations)
             {
-                if (a.Text is null && a.Sid != 0)
+                if (a.Text is null && a.ImportLocation != default)
                 {
                     var symtab = GetSymbolTable();
-                    if (a.Sid < -1 || a.Sid > symtab.MaxId)
+                    if (a.ImportLocation.Sid < -1 || a.ImportLocation.Sid > symtab.MaxId)
                     {
                         throw new UnknownSymbolException(a.Sid);
                     }
 
-                    var text = symtab.FindKnownSymbol(a.Sid);
-                    yield return new SymbolToken(text, a.Sid);
+                    var text = symtab.FindKnownSymbol(a.ImportLocation.Sid);
+                    yield return new SymbolToken(text, a.Sid, a.ImportLocation);
                 }
                 else
                 {

IonDotnet/SymbolToken.cs

@@ -26,12 +26,28 @@ namespace IonDotnet
 
         private readonly int _sid;
 
+        /// <summary>
+        /// The text of this symbol.
+        /// </summary>
+        public readonly string Text;
+
+        /// <summary>
+        /// The ID of this symbol token.
+        /// </summary>
+        public int Sid => _sid - 1;
+
+        /// <summary>
+        /// The import location of this symbol token.
+        /// </summary>
+        public readonly ImportLocation ImportLocation;
+
         /// <summary>
         /// Create a new symbol token.
         /// </summary>
         /// <param name="text">Text</param>
         /// <param name="sid">Sid</param>
-        public SymbolToken(string text, int sid)
+        /// <param name="importLocation">ImportLocation</param>
+        public SymbolToken(string text, int sid, ImportLocation importLocation = default)
         {
             /**
              * Note: due to the fact that C# structs are initialized 'blank' (all fields 0), and we want the default
@@ -41,22 +57,13 @@ public SymbolToken(string text, int sid)
 
             Text = text;
             _sid = sid + 1;
+            ImportLocation = importLocation;
         }
 
-        /// <summary>
-        /// The text of this symbol.
-        /// </summary>
-        public readonly string Text;
-
-        /// <summary>
-        /// The ID of this symbol token.
-        /// </summary>
-        public int Sid => _sid - 1;
-
         //Override everything to avoid boxing allocation
-        public override string ToString() => $"SymbolToken::{{text:{Text}, id:{Sid}}}";
+        public override string ToString() => $"SymbolToken::{{text:{Text}, id:{Sid}, importLocation:{ImportLocation.ToString()}}}";
 
-        public static bool operator ==(SymbolToken x, SymbolToken y) => x.Text == y.Text && x._sid == y._sid;
+        public static bool operator ==(SymbolToken x, SymbolToken y) => x.Text == y.Text && x.Sid == y.Sid && x.ImportLocation == y.ImportLocation;
 
         public static bool operator !=(SymbolToken x, SymbolToken y) => !(x == y);
 
@@ -73,7 +80,7 @@ public bool IsEquivalentTo(SymbolToken other)
             if (other.Text != null)
                 return false;
 
-            return other.Sid == Sid;
+            return other.ImportLocation == ImportLocation;
         }
     }
 }

IonDotnet/Tree/IonSymbol.cs

@@ -5,14 +5,16 @@ namespace IonDotnet.Tree
     public sealed class IonSymbol : IonText
     {
         private int _sid;
+        private ImportLocation _importLocation;
 
-        public IonSymbol(string text, int sid = SymbolToken.UnknownSid) : this(new SymbolToken(text, sid))
+        public IonSymbol(string text, int sid = SymbolToken.UnknownSid, ImportLocation importLocation = default) : this(new SymbolToken(text, sid, importLocation))
         {
         }
 
         public IonSymbol(SymbolToken symbolToken) : base(symbolToken.Text, symbolToken == default)
         {
             _sid = symbolToken.Sid;
+            _importLocation = symbolToken.ImportLocation;
         }
 
         private IonSymbol(bool isNull) : base(null, isNull)
@@ -28,7 +30,7 @@ public override bool IsEquivalentTo(IonValue other)
         {
             if (!base.IsEquivalentTo(other))
                 return false;
-            
+
             if (!(other is IonSymbol oSymbol))
                 return false;
 
@@ -63,11 +65,12 @@ public override string StringValue
 
         public SymbolToken SymbolValue
         {
-            get => new SymbolToken(StringVal, _sid);
+            get => new SymbolToken(StringVal, _sid, _importLocation);
             set
             {
                 StringValue = value.Text;
                 _sid = value.Sid;
+                _importLocation = value.ImportLocation;
             }
         }
     }