WIP: Lots of work getting compilation to go, with debugging prints all over. Don't look at this.

Author: dmiller

Clojure/Clojure.Source/clojure/genclass.clj

@@ -320,5 +320,5 @@
   {:added "1.0"}
 
   [& options]
-  (let [options-map (into1 {} (map vec (partition 2 options))) ]
-          `'~(generate-interface options-map)))
+  (let [options-map (apply hash-map options) ]
+  `(parse-eval* (#'clojure.core/generate-interface '~options-map))))

Clojure/Clojure.Source/clojure/pprint/pretty_writer.clj

@@ -427,7 +427,7 @@
                 (setf :buffer []))
                (write-white-space this)))
 	  (Flush []                                    ;; flush
-             (.ppflush ^PrettyFlush this)
+             (.ppflush ^clojure.pprint.PrettyFlush this)
              (let [^TextWriter w (getf :base)]
                (.Flush w)))                        ;;; .flush
 

Clojure/Clojure/CljCompiler/Ast/ParseEvalExpr.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace clojure.lang.CljCompiler.Ast
+{
+    public class ParseEvalExpr : Expr
+    {
+        Expr _expr;
+
+        public ParseEvalExpr(Expr expr)
+        {
+            _expr = expr;
+        }
+
+        public bool HasClrType => throw new NotImplementedException();
+
+        public Type ClrType => throw new NotImplementedException();
+
+        public sealed class Parser : IParser
+        {
+
+
+            public Expr Parse(ParserContext pcon, object form)
+            {
+                // The whole point is just to evaluate the expression during parsing,
+                // similar to  FnExpr doing ObjExpr.Compile during parsing in order to generate the function type.
+
+                var expr = Compiler.Analyze(pcon, RT.second(form));
+                expr.Eval();
+                return new ParseEvalExpr(expr);
+            }
+        }
+
+        public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg)
+        {
+            Compiler.NilExprInstance.Emit(rhc, objx, ilg);
+        }
+
+        public object Eval()
+        {
+            return null;
+        }
+
+        public bool HasNormalExit()
+        {
+            return true;
+        }
+    }
+}

Clojure/Clojure/CljCompiler/Compiler.cs

@@ -55,13 +55,17 @@ internal static Type FindDuplicateType(string typename)
             _evalTypeMap.TryGetValue(typename, out Type type);
             return type;
         }
+
+        internal static Type FindDuplicateCompiledType(string typename) => null;
+
 #else
         internal static void RegisterDuplicateType(Type type)
         {
             if (Compiler.IsCompiling)
                 _compilerTypeMap[type.FullName] = type;
             else
                 _evalTypeMap[type.FullName] = type;
+            Console.WriteLine($"Register {type.FullName}, isCompilning = {Compiler.IsCompiling}");
         }
 
         internal static Type FindDuplicateType(string typename)
@@ -72,6 +76,15 @@ internal static Type FindDuplicateType(string typename)
             _evalTypeMap.TryGetValue(typename, out Type type);
             return type;
         }
+
+        internal static Type FindDuplicateCompiledType(string typename)
+        {
+            if (_compilerTypeMap.TryGetValue(typename, out Type compiledType))
+                return compiledType;
+            else
+                return null;
+        }
+
 #endif
 
         #endregion
@@ -107,6 +120,8 @@ internal static Type FindDuplicateType(string typename)
         public static readonly Symbol ReifySym = Symbol.intern("reify*");
         public static readonly Symbol AmpersandSym = Symbol.intern("&");
 
+        public static readonly Symbol ParseEvalSym = Symbol.intern("parse-eval*");
+
         public static readonly Symbol IdentitySym = Symbol.intern("clojure.core", "identity");
 
         static readonly Symbol NsSym = Symbol.intern("ns");
@@ -301,7 +316,8 @@ public static object ElideMeta(object m)
             CatchSym, null,
             FinallySym, null,
             NewSym, new NewExpr.Parser(),
-            AmpersandSym, null
+            AmpersandSym, null,
+            ParseEvalSym, new ParseEvalExpr.Parser()
         );
 
         public static bool IsSpecial(Object sym)
@@ -620,7 +636,7 @@ private static object ResolveIn(Namespace n, Symbol symbol, bool allowPrivate)
         public static object maybeResolveIn(Namespace n, Symbol symbol)
         {
             // note: ns-qualified vars must already exist
-            if (symbol.Namespace != null)
+             if (symbol.Namespace != null)
             {
                 Namespace ns = namespaceFor(n, symbol);
                 if (ns == null)
@@ -641,7 +657,16 @@ public static object maybeResolveIn(Namespace n, Symbol symbol)
             else
             {
                 object o = n.GetMapping(symbol);
+                if (o is Type type)
+                {
+                    var tName = type.FullName;
+                    var compiledType = Compiler.FindDuplicateCompiledType(tName);
+                    if ( compiledType is not null && Compiler.IsCompiling)
+                        return compiledType;                       
+                }
+
                 return o;
+
             }
         }
 

Clojure/Clojure/CljCompiler/GenInterface.cs

@@ -22,6 +22,7 @@ public static class GenInterface
 
         public static Type GenerateInterface(string iName, IPersistentMap attributes, Seqable extends, ISeq methods)
         {
+            Console.WriteLine($"Generating inteface {iName}, isCompiling = {Compiler.IsCompiling}");
             iName = iName.Replace('-', '_');
 
             GenContext context;

Clojure/Clojure/CljCompiler/GenProxy.cs

@@ -416,13 +416,23 @@ private static void AddInterfaceProperties(
             }
 
             foreach (Type ifType in allInterfaces)
-                foreach (PropertyInfo p in ifType.GetProperties())
+            {
+                try
                 {
-                    MethodSignature sig = new MethodSignature(p);
-                    if (!considered.Contains(sig))
-                        properties.Add(p);
-                    considered.Add(sig);
+                    foreach (PropertyInfo p in ifType.GetProperties())
+                    {
+                        MethodSignature sig = new MethodSignature(p);
+                        if (!considered.Contains(sig))
+                            properties.Add(p);
+                        considered.Add(sig);
+                    }
+                } 
+                catch (NotSupportedException e)
+                {
+                    // do nothing
+                    // Types in PersistedAssemblyBuilders throw on GetProperties
                 }
+            }
             foreach (PropertyInfo pi in properties)
             {
                 PropertyBuilder pb = proxyTB.DefineProperty(pi.Name,

Clojure/Clojure/Lib/RT.cs

@@ -2763,10 +2763,22 @@ public static string PrintToConsole(object x)
         public static Type classForName(string p)
         {
 
+            // This used to come later.  Moved it up to the top for compiling definterface, e.g.
+            //  (definterface IMyInterface ... )
+            //  First compiled create IMyInterface classs, gets stored in the compiled-types map.
+            //  Then eval'd so the we update the current environment and store the the eval-types map.
+            //  However, definterface does an import, it picks up the version in the eval-types map.
+            //  When a subsequent call tries to get IMyInterface, it was being found by Type.GetType.
+            //  So code being compiled was picking up the eval'd version instead of the compiled version.
+
+            Type t = Compiler.FindDuplicateType(p);
+            if (t != null)
+                return t;
+
             // fastest path, will succeed for assembly qualified names (returned by Type.AssemblyQualifiedName)
             // or namespace qualified names (returned by Type.FullName) in the executing assembly or mscorlib
             // e.g. "UnityEngine.Transform, UnityEngine, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"
-            Type t = Type.GetType(p, false);
+            t = Type.GetType(p, false);
 
             // Added the IsPublic check to deal with shadowed types in .Net Core,
             // e.g. System.Environment in assemblies System.Private.CoreLib and System.Runtime.Exceptions.
@@ -2775,9 +2787,8 @@ public static Type classForName(string p)
             if (t != null && (t.IsPublic || t.IsNestedPublic))
                 return t;
 
-            t = Compiler.FindDuplicateType(p);
-            if (t != null)
-                return t;
+
+
 
             AppDomain domain = AppDomain.CurrentDomain;
             Assembly[] assys = domain.GetAssemblies();

Clojure/Clojure/Runtime/Reflector.cs

@@ -61,9 +61,18 @@ static public PropertyInfo GetProperty(Type t, String name, bool getStatics)
 
             foreach (Type type in typesToCheck)
             {
-                IEnumerable<PropertyInfo> einfo
-                     = type.GetProperties(flags).Where(info => info.Name == name && info.GetIndexParameters().Length == 0);
-                pinfos.AddRange(einfo);
+                try
+                {
+
+                    IEnumerable<PropertyInfo> einfo
+                         = type.GetProperties(flags).Where(info => info.Name == name && info.GetIndexParameters().Length == 0);
+                    pinfos.AddRange(einfo);
+                }
+                catch (NotSupportedException)
+                {
+                    // do nothing
+                    // Types in PersistedAssemblyBuilders throw on GetProperties
+                }
             }