Implement IL codes for #91, #93, fix #105

IL2C.Core/ILConveters/ArithmeticalConverters.cs

@@ -234,4 +234,80 @@ public override ExpressionEmitter Prepare(DecodeContext decodeContext)
                 ArithmeticalConverterUtilities.BinaryOperators.Rem, decodeContext);
         }
     }
+
+    internal sealed class NotConverter : InlineNoneConverter
+    {
+        public override OpCode OpCode => OpCodes.Not;
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            var si0 = decodeContext.PopStack();
+            Metadata.ILocalVariableInformation result;
+
+            if (si0.TargetType.IsFloatStackFriendlyType || si0.TargetType.IsByReference)
+                throw new InvalidProgramSequenceException(
+                    "Invalid arithmetical NOT operation: Location={0}, Type0={1}",
+                    decodeContext.CurrentCode.RawLocation,
+                    si0.TargetType.FriendlyName);
+
+            if (si0.TargetType.IsInt32StackFriendlyType)
+            {
+                result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int32Type);
+            }
+            else
+            {   // Int64 = ~(Int64)
+                result = decodeContext.PushStack(decodeContext.PrepareContext.MetadataContext.Int64Type);
+            }
+
+            return (extractContext, _) => new[] { string.Format(
+                    "{0} = ~{1}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0)) };
+        }
+    }
+
+    internal enum ShiftDirection
+    {
+        Left, Right
+    }
+
+    internal abstract class ShiftConverter : InlineNoneConverter
+    {
+        public abstract ShiftDirection Direction { get; }
+
+        public override ExpressionEmitter Prepare(DecodeContext decodeContext)
+        {
+            var si1 = decodeContext.PopStack();
+            var si0 = decodeContext.PopStack();
+
+            if (si0.TargetType.IsFloatStackFriendlyType || si0.TargetType.IsByReference || !si1.TargetType.IsInt32Type)
+                throw new InvalidProgramSequenceException(
+                    "Invalid arithmetical NOT operation: Location={0}, Type0={1}",
+                    decodeContext.CurrentCode.RawLocation,
+                    si0.TargetType.FriendlyName);
+
+            var result = decodeContext.PushStack(si0.TargetType);
+
+            return (extractContext, _) => new[] { string.Format(
+                    "{0} = {1} {2} {3}",
+                    extractContext.GetSymbolName(result),
+                    extractContext.GetSymbolName(si0),
+                    Direction == ShiftDirection.Left ? "<<" : ">>",
+                    extractContext.GetSymbolName(si1)) };
+        }
+    }
+
+    internal sealed class ShiftRightConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shr;
+
+        public override ShiftDirection Direction => ShiftDirection.Right;
+    }
+
+    internal sealed class ShiftLeftConverter : ShiftConverter
+    {
+        public override OpCode OpCode => OpCodes.Shl;
+
+        public override ShiftDirection Direction => ShiftDirection.Left;
+    }
 }

IL2C.Core/Metadata/MetadataContext.cs

@@ -112,9 +112,12 @@ internal MetadataContext(string assemblyPath, bool readSymbols)
 
             this.MainAssembly = mainAssemblyInformation;
             assemblies.Add(mainAssembly, mainAssemblyInformation);
-            assemblies.Add(resolvedCoreAssembly, resolvedCoreAssemblyInformation);
-            modules.Add(resolvedCoreModule, resolvedCoreModuleInformation);
-            assemblyByModule.Add(resolvedCoreModule, resolvedCoreAssembly);
+            if (!assemblies.ContainsKey(resolvedCoreAssembly))
+            {
+                assemblies.Add(resolvedCoreAssembly, resolvedCoreAssemblyInformation);
+                modules.Add(resolvedCoreModule, resolvedCoreModuleInformation);
+                assemblyByModule.Add(resolvedCoreModule, resolvedCoreAssembly);
+            }
 
             this.VoidType = this.GetOrAddType(resolvedCoreModule.TypeSystem.Void);
             this.ObjectType = this.GetOrAddType(resolvedCoreModule.TypeSystem.Object);

IL2C.Core/Metadata/MetadataUtilities.cs

@@ -424,10 +424,27 @@ public MethodSignatureComparerImpl(bool isVirtual)
 
             public int Compare(IMethodInformation x, IMethodInformation y)
             {
-                var rn = x.Name.CompareTo(y.Name);
+                var xname = x.Name;
+                var yname = y.Name;
+
+                var rn = xname.CompareTo(yname);
                 if (rn != 0)
                 {
-                    return rn;
+                    // If it is an explicit interface implementation, we need to compare with it's full name
+                    if (x.DeclaringType.IsInterface)
+                    {
+                        xname = $"{x.DeclaringType.FriendlyName}.{xname}";
+                    }
+                    if (y.DeclaringType.IsInterface)
+                    {
+                        yname = $"{y.DeclaringType.FriendlyName}.{yname}";
+                    }
+
+                    rn = xname.CompareTo(yname);
+                    if (rn != 0)
+                    {
+                        return rn;
+                    }
                 }
 
                 var xps = x.Parameters;
@@ -449,9 +466,25 @@ public int Compare(IMethodInformation x, IMethodInformation y)
 
             public bool Equals(IMethodInformation x, IMethodInformation y)
             {
-                if (x.Name != y.Name)
+                var xname = x.Name;
+                var yname = y.Name;
+
+                if (xname != yname)
                 {
-                    return false;
+                    // If it is an explicit interface implementation, we need to compare with it's full name
+                    if (x.DeclaringType.IsInterface)
+                    {
+                        xname = $"{x.DeclaringType.FriendlyName}.{xname}";
+                    }
+                    if (y.DeclaringType.IsInterface)
+                    {
+                        yname = $"{y.DeclaringType.FriendlyName}.{yname}";
+                    }
+
+                    if (xname != yname)
+                    {
+                        return false;
+                    }
                 }
 
                 var xps = x.Parameters;