Fix handling of zero-arity calls in QME

Author: dmiller

Clojure/Clojure.Tests/clojure/test_clojure/errors.clj

@@ -51,7 +51,7 @@
 
 (deftest compile-error-examples
   (are [form errtype re] (thrown-with-cause-msg? errtype re (eval form))
-       '(Int32/Parse) Exception #"No matching member.*taking 0 args"                                 ;;; Long/parseLong  #"No method.*taking 0 args"
+       '(Int32/Parse) Exception #"No .*taking 0 args"                                                ;;; Long/parseLong  #"No method.*taking 0 args"
        '(Int32/Parse :a :b :c :d) Exception #"No matching member.*taking 4 args")                    ;;; (Long/parseLong :a :b :c)  #"No matching method.*taking 3 args" 
   (are [form errtype re] (thrown-with-msg? errtype re (eval form))
        '(.jump "foo" 1) Exception #"No matching member.*taking 1 arg"))                              ;;; #"No matching method.*taking 1 arg"

Clojure/Clojure/CljCompiler/Ast/InstanceFieldExpr.cs

@@ -49,7 +49,7 @@ public abstract class InstanceFieldOrPropertyExpr<TInfo> : FieldOrPropertyExpr
 
         #region Ctors
 
-        protected InstanceFieldOrPropertyExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string memberName, TInfo tinfo)
+        protected InstanceFieldOrPropertyExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string memberName, TInfo tinfo, bool ignoreNullTargetType=false)
         {
             _source = source;
             _spanMap = spanMap;
@@ -58,8 +58,8 @@ protected InstanceFieldOrPropertyExpr(string source, IPersistentMap spanMap, Sym
             _tinfo = tinfo;
             _tag = tag;
 
-            _targetType = target.HasClrType ? target.ClrType : null;
-
+            _targetType = target.HasClrType ? target.ClrType : ignoreNullTargetType ? typeof(object) : null;
+           
             // Java version does not include check on _targetType
             // However, this seems consistent with the checks in the generation code.
             if ((_targetType == null || _tinfo == null) && RT.booleanCast(RT.WarnOnReflectionVar.deref()))
@@ -182,8 +182,8 @@ public sealed class InstanceFieldExpr : InstanceFieldOrPropertyExpr<FieldInfo>
     {
         #region C-tors
 
-        public InstanceFieldExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string fieldName, FieldInfo finfo)
-            :base(source,spanMap,tag,target,fieldName,finfo)  
+        public InstanceFieldExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string fieldName, FieldInfo finfo, bool ignoreNullTargetType = false)
+            :base(source,spanMap,tag,target,fieldName,finfo,ignoreNullTargetType)  
         {
         }
 
@@ -270,8 +270,8 @@ public sealed class InstancePropertyExpr : InstanceFieldOrPropertyExpr<PropertyI
     {
         #region C-tors
 
-        public InstancePropertyExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string propertyName, PropertyInfo pinfo)
-            :base(source,spanMap,tag, target,propertyName,pinfo)  
+        public InstancePropertyExpr(string source, IPersistentMap spanMap, Symbol tag, Expr target, string propertyName, PropertyInfo pinfo, bool ignoreNullTargetType = false)
+            :base(source,spanMap,tag, target,propertyName,pinfo,ignoreNullTargetType)  
         {
         }
 

Clojure/Clojure/CljCompiler/Ast/InvokeExpr.cs

@@ -239,21 +239,77 @@ public static Expr Parse(ParserContext pcon, ISeq form)
 
         static Expr ToHostExpr(ParserContext pcon, QualifiedMethodExpr qmfexpr, Symbol tag, bool tailPosition, ISeq args)
         {
-            // Let's see if we have generic type parameters.  We'll ignore this if we are a constructor -- constructors can't be generic.
+            var source = (string)Compiler.SourceVar.deref();
+            var spanMap = (IPersistentMap)Compiler.SourceSpanVar.deref();
+
+
+            // we have the form (qmfexpr ...args...)
+            // We need to decide what the pieces are in ...args...
+
+            Expr instance = null;
+            if (qmfexpr.Kind == QualifiedMethodExpr.EMethodKind.INSTANCE)
+            {
+                instance = Compiler.Analyze(pcon.EvalOrExpr(), RT.first(args));
+                args = RT.next(args);
+            }
+
+            // We handle zero-arity calls separately, similarly to how HostExpr handles them.
+            // Constructors not included here.
+            // We are trying to discriminate field access, property access, and method calls on zero arguments.
+            // 
+            // One special case here:  Suppose we have a zero-arity _generic_method call, with type-args provided.
+            // THis will look like:   (Type/StaticMethod (type-args type1 ..))  or (Type/InstanceMEthod instance-expression (type-args type1 ..))
+            // We check for the arg count before removing the type-args, so these will be handled by the non-zero-arity code.
+            // That is okay -- because this is generic, it can't be a field or property access, so we can treat it as a method call.
+
+            bool isZeroArity = RT.count(args) == 0 && qmfexpr.Kind != QualifiedMethodExpr.EMethodKind.CTOR;
+
+            if (isZeroArity)
+            {
+                PropertyInfo pinfo;
+                FieldInfo finfo;
+
+                switch (qmfexpr.Kind)
+                {
+                    case QualifiedMethodExpr.EMethodKind.INSTANCE:
+                        if ( (finfo = Reflector.GetField(qmfexpr.MethodType, qmfexpr.MethodName,false)) != null)
+                            return new InstanceFieldExpr(source, spanMap, tag, instance, qmfexpr.MethodName, finfo, true);
+                        if ((pinfo = Reflector.GetProperty(qmfexpr.MethodType, qmfexpr.MethodName, false)) != null)
+                            return new InstancePropertyExpr(source, spanMap, tag, instance, qmfexpr.MethodName, pinfo, true);
+                        if (Reflector.GetArityZeroMethod(qmfexpr.MethodType, qmfexpr.MethodName, false) != null)
+                            return new InstanceMethodExpr(source, spanMap, tag, instance, qmfexpr.MethodType, qmfexpr.MethodName, null, new List<HostArg>(), tailPosition);
+                        throw new MissingMemberException(String.Format("No instance field, property, or method taking 0 args named {0} found for {1}", qmfexpr.MethodName, qmfexpr.MethodType.Name));
+
+                    case QualifiedMethodExpr.EMethodKind.STATIC:
+                        if ((finfo = Reflector.GetField(qmfexpr.MethodType, qmfexpr.MethodName, true)) != null)
+                            return new StaticFieldExpr(source, spanMap, tag, qmfexpr.MethodType, qmfexpr.MethodName, finfo);
+                        if ((pinfo = Reflector.GetProperty(qmfexpr.MethodType, qmfexpr.MethodName, true)) != null)
+                            return new StaticPropertyExpr(source, spanMap, tag, qmfexpr.MethodType, qmfexpr.MethodName, pinfo);
+                        if (Reflector.GetArityZeroMethod(qmfexpr.MethodType, qmfexpr.MethodName, true) != null)
+                            return new StaticMethodExpr(source, spanMap, tag, qmfexpr.MethodType, qmfexpr.MethodName, null, new List<HostArg>(), tailPosition);
+                        throw new MissingMemberException(String.Format("No static field, property, or method taking 0 args named {0} found for {1}", qmfexpr.MethodName, qmfexpr.MethodType.Name));
+
+                    default:
+                        // Constructor -- this won't happen, we fall through to the code below.
+                        break;
+                }
+            }
 
 
             object firstArg = RT.first(args);
             List<Type> genericTypeArgs = null;
-            ISeq processedArgs = args;
 
             if (firstArg is ISeq && RT.first(firstArg) is Symbol symbol && symbol.Equals(HostExpr.TypeArgsSym))
             {
                 // We have a type args supplied for a generic method call
                 // (. thing methodname (type-args type1 ... ) args ...)
                 genericTypeArgs = HostExpr.ParseGenericMethodTypeArgs(RT.next(firstArg));
-                processedArgs = RT.next(args);
+                args = RT.next(args);
             }
 
+
+
+
             if (qmfexpr.HintedSig != null )
             {
                 MethodBase method = QualifiedMethodExpr.ResolveHintedMethod(qmfexpr.MethodType, qmfexpr.MethodName, qmfexpr.Kind, qmfexpr.HintedSig);
@@ -264,31 +320,31 @@ static Expr ToHostExpr(ParserContext pcon, QualifiedMethodExpr qmfexpr, Symbol t
                             qmfexpr.MethodType, 
                             (ConstructorInfo)method, 
                             HostExpr.ParseArgs(pcon, args), 
-                            (IPersistentMap)Compiler.SourceSpanVar.deref());
+                            spanMap);
 
                     case QualifiedMethodExpr.EMethodKind.INSTANCE:
                         return new InstanceMethodExpr(
-                            (string)Compiler.SourceVar.deref(),
-                            (IPersistentMap)Compiler.SourceSpanVar.deref(),
+                            source, 
+                            spanMap,
                             tag,
-                            Compiler.Analyze(pcon.EvalOrExpr(), RT.first(processedArgs)),
+                            instance,
                             qmfexpr.MethodType,
                             Compiler.munge(qmfexpr.MethodName), 
                             (MethodInfo)method,
                             genericTypeArgs,                 
-                            HostExpr.ParseArgs(pcon, RT.next(processedArgs)),
+                            HostExpr.ParseArgs(pcon, args),
                             tailPosition);
 
                     default:
                         return new StaticMethodExpr(
-                            (string)Compiler.SourceVar.deref(),
-                            (IPersistentMap)Compiler.SourceSpanVar.deref(),
+                            source,
+                            spanMap,
                             tag, 
                              qmfexpr.MethodType,
                              Compiler.munge(qmfexpr.MethodName), 
                              (MethodInfo)method,
                              genericTypeArgs,
-                             HostExpr.ParseArgs(pcon,processedArgs),
+                             HostExpr.ParseArgs(pcon,args),
                              tailPosition);
                 }
             }
@@ -307,11 +363,11 @@ static Expr ToHostExpr(ParserContext pcon, QualifiedMethodExpr qmfexpr, Symbol t
                             (string)Compiler.SourceVar.deref(),
                             (IPersistentMap)Compiler.SourceSpanVar.deref(),
                             tag,
-                            Compiler.Analyze(pcon.EvalOrExpr(), RT.first(processedArgs)),
+                            instance,
                             qmfexpr.MethodType,
                             Compiler.munge(qmfexpr.MethodName),
                             genericTypeArgs,
-                            HostExpr.ParseArgs(pcon, RT.seq(RT.next(processedArgs))),
+                            HostExpr.ParseArgs(pcon, args),
                             tailPosition);
 
                     default:
@@ -322,13 +378,12 @@ static Expr ToHostExpr(ParserContext pcon, QualifiedMethodExpr qmfexpr, Symbol t
                             qmfexpr.MethodType,
                             Compiler.munge(qmfexpr.MethodName),
                             genericTypeArgs,
-                            HostExpr.ParseArgs(pcon, processedArgs),
+                            HostExpr.ParseArgs(pcon, args),
                             tailPosition);
                 }
             }
         }
 
-
         #endregion
 
         #region eval