Fix for issue 1480: analyze a method even if it does not have a body, and do not try to evaluate ...

dart/frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 function $defProp(obj, prop, value) {
   Object.defineProperty(obj, prop,
       {value: value, enumerable: false, writable: true, configurable: true});
 }
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
@@ skipping 117 matching lines @@
     return (tmp < 0) ? Math.ceil(tmp) : Math.floor(tmp);
   } else {
     return x.$truncdiv(y);
   }
 }
 // ********** Code for Object **************
 $defProp(Object.prototype, "get$dynamic", function() {
   "use strict"; return this;
 });
 $defProp(Object.prototype, "noSuchMethod", function(name, args) {
-  $throw(new NoSuchMethodException(this, name, args));
+  $throw(new NoSuchMethodException(this, name, args, ""));
 });
 $defProp(Object.prototype, "_pushBlock$1", function($0) {
   return this.noSuchMethod("_pushBlock", [$0]);
 });
 $defProp(Object.prototype, "analyze$1", function($0) {
   return this.noSuchMethod("analyze", [$0]);
 });
 $defProp(Object.prototype, "contains$1", function($0) {
   return this.noSuchMethod("contains", [$0]);
 });
@@ skipping 41 matching lines @@
 });
 $defProp(Object.prototype, "substring$1", function($0) {
   return this.noSuchMethod("substring", [$0]);
 });
 $defProp(Object.prototype, "toString$0", function() {
   return this.toString();
 });
 $defProp(Object.prototype, "visitBinaryExpression$1", function($0) {
   return this.noSuchMethod("visitBinaryExpression", [$0]);
 });
+$defProp(Object.prototype, "visitCallExpression$1", function($0) {
+  return this.noSuchMethod("visitCallExpression", [$0]);
+});
 $defProp(Object.prototype, "visitPostfixExpression$1", function($0) {
   return this.noSuchMethod("visitPostfixExpression", [$0]);
 });
 $defProp(Object.prototype, "write$1", function($0) {
   return this.noSuchMethod("write", [$0]);
 });
 // ********** Code for Clock **************
 function Clock() {}
 Clock.now = function() {
   return new Date().getTime();
@@ skipping 12 matching lines @@
 IndexOutOfRangeException.prototype.toString$0 = IndexOutOfRangeException.prototype.toString;
 // ********** Code for IllegalAccessException **************
 function IllegalAccessException() {
 
 }
 IllegalAccessException.prototype.toString = function() {
   return "Attempt to modify an immutable object";
 }
 IllegalAccessException.prototype.toString$0 = IllegalAccessException.prototype.toString;
 // ********** Code for NoSuchMethodException **************
-function NoSuchMethodException(_receiver, _functionName, _arguments) {
+function NoSuchMethodException(_receiver, _functionName, _arguments, _extraMessage) {
   this._receiver = _receiver;
   this._functionName = _functionName;
+  this._extraMessage = _extraMessage;
   this._arguments = _arguments;
 }
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = (0);
    i < this._arguments.get$length(); i++) {
     if (i > (0)) {
       sb.add(", ");
     }
     sb.add(this._arguments.$index(i));
   }
   sb.add("]");
-  return $add(("NoSuchMethodException - receiver: '" + this._receiver + "' "), ("function name: '" + this._functionName + "' arguments: [" + sb + "]"));
+  var x = this._extraMessage;
+  return $add(("NoSuchMethodException - receiver: '" + this._receiver + "' "), ("function name: '" + this._functionName + "' arguments: [" + sb + "]" + x));
 }
 NoSuchMethodException.prototype.toString$0 = NoSuchMethodException.prototype.toString;
 // ********** Code for ClosureArgumentMismatchException **************
 function ClosureArgumentMismatchException() {
 
 }
 ClosureArgumentMismatchException.prototype.toString = function() {
   return "Closure argument mismatch";
 }
 ClosureArgumentMismatchException.prototype.toString$0 = ClosureArgumentMismatchException.prototype.toString;
 // ********** Code for ObjectNotClosureException **************
 function ObjectNotClosureException() {
 
 }
 ObjectNotClosureException.prototype.toString = function() {
   return "Object is not closure";
 }
 ObjectNotClosureException.prototype.toString$0 = ObjectNotClosureException.prototype.toString;
 // ********** Code for IllegalArgumentException **************
-function IllegalArgumentException(args) {
-  this._args = args;
+function IllegalArgumentException(arg) {
+  this._arg = arg;
 }
 IllegalArgumentException.prototype.is$IllegalArgumentException = function(){return true};
 IllegalArgumentException.prototype.toString = function() {
-  return ("Illegal argument(s): " + this._args);
+  return ("Illegal argument(s): " + this._arg);
 }
 IllegalArgumentException.prototype.toString$0 = IllegalArgumentException.prototype.toString;
 // ********** Code for StackOverflowException **************
 function StackOverflowException() {
 
 }
 StackOverflowException.prototype.toString = function() {
   return "Stack Overflow";
 }
 StackOverflowException.prototype.toString$0 = StackOverflowException.prototype.toString;
@@ skipping 1505 matching lines @@
   }
   var values = [];
   var $$list = this.method.parameters;
   for (var $$i = $$list.iterator(); $$i.hasNext(); ) {
     var p = $$i.next();
     values.add(new PureStaticValue(p.get$type(), null, false, false));
   }
   var args = new Arguments(null, values);
   this._frame = new CallFrame(this, this.method, thisValue, args, context);
   this._bindArguments(this._frame.args);
-  this.body.visit(this);
+  var declaredInitializers = this.method.definition.get$dynamic().get$initializers();
+  if ($ne(declaredInitializers)) {
+    for (var $$i = declaredInitializers.iterator(); $$i.hasNext(); ) {
+      var init = $$i.next();
+      if ((init instanceof CallExpression)) {
+        this.visitCallExpression(init, true);
+      }
+    }
+  }
+  if (this.body != null) this.body.visit(this);
 }
 MethodAnalyzer.prototype._hasTypeParams = function(node) {
   if ((node instanceof NameTypeReference)) {
     var name = node.get$name().get$name();
     return (this.method.declaringType.lookupTypeParam(name) != null);
   }
   else if ((node instanceof GenericTypeReference)) {
     var $$list = node.get$typeArguments();
     for (var $$i = $$list.iterator(); $$i.hasNext(); ) {
       var typeArg = $$i.next();
@@ skipping 256 matching lines @@
 }
 MethodAnalyzer.prototype.visitEmptyStatement = function(node) {
 
 }
 MethodAnalyzer.prototype.visitLambdaExpression = function(node) {
   var name = (node.func.name != null) ? node.func.name.name : "";
   var meth = this._makeLambdaMethod(name, node.func);
   meth.get$methodData().analyze();
   return this._frame._makeValue($globals.world.functionType, node);
 }
-MethodAnalyzer.prototype.visitCallExpression = function(node) {
+MethodAnalyzer.prototype.analyzeInitializerConstructorCall = function(node, receiver, name) {
+  var type = this._frame.method.declaringType;
+  if ((receiver instanceof SuperExpression)) {
+    type = type.get$parent();
+  }
+  var member = type.getConstructor(name == null ? "" : name);
+  if (null != member) {
+    return member.invoke(this._frame, node, this._frame.makeThisValue(node), this._visitArgs(node.arguments));
+  }
+  else {
+    var constructorName = name == null ? "" : ("." + name);
+    $globals.world.warning(("cannot find constructor \"" + type.get$name() + constructorName + "\""), node.span);
+    return this._frame._makeValue($globals.world.varType, node);
+  }
+}
+MethodAnalyzer.prototype.isThisOrSuper = function(node) {
+  return (node instanceof ThisExpression) || (node instanceof SuperExpression);
+}
+MethodAnalyzer.prototype.visitCallExpression = function(node, visitingInitializers) {
   var target;
   var position = node.target;
   var name = ":call";
   if ((node.target instanceof DotExpression)) {
     var dot = node.target;
     target = dot.self.visit(this);
     name = dot.name.name;
-    position = dot.name;
+    if (this.isThisOrSuper(dot.self) && visitingInitializers) {
+      return this.analyzeInitializerConstructorCall(node, dot.self, name);
+    }
+    else {
+      position = dot.name;
+    }
+  }
+  else if (this.isThisOrSuper(node.target) && visitingInitializers) {
+    return this.analyzeInitializerConstructorCall(node, node.target, null);
   }
   else if ((node.target instanceof VarExpression)) {
     var varExpr = node.target;
     name = varExpr.name.name;
     target = this._frame.lookup(name);
     if ($ne(target)) {
       return target.get(position).invoke(this._frame, ":call", node, this._visitArgs(node.arguments));
     }
     var member = this._resolveBare(name, varExpr.name);
     if (null != member) {
@@ skipping 241 matching lines @@
   return new PureStaticValue(node.value.get$type(), node.span, true, false);
 }
 MethodAnalyzer.prototype.visitStringInterpExpression = function(node) {
   return this._frame._makeValue($globals.world.stringType, node);
 }
 MethodAnalyzer.prototype._pushBlock$1 = MethodAnalyzer.prototype._pushBlock;
 MethodAnalyzer.prototype.analyze$1 = MethodAnalyzer.prototype.analyze;
 MethodAnalyzer.prototype.visitBinaryExpression$1 = function($0) {
   return this.visitBinaryExpression($0, false);
 };
+MethodAnalyzer.prototype.visitCallExpression$1 = function($0) {
+  return this.visitCallExpression($0, false);
+};
 MethodAnalyzer.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression($0, false);
 };
 // ********** Code for CallFrame **************
 function CallFrame(analyzer, method, thisValue, args, enclosingFrame) {
   this.args = args;
   this.analyzer = analyzer;
   this.enclosingFrame = enclosingFrame;
   this.method = method;
   this.thisValue = thisValue;
@@ skipping 1435 matching lines @@
     var p = this.method.get$parameters().$index(i);
     var currentArg = null;
     if (i < args.get$bareCount()) {
       currentArg = args.values.$index(i);
     }
     else {
       currentArg = args.getValue(p.get$name());
       if (null == currentArg) {
         p.genValue(this.method, this);
         currentArg = p.get$value();
+        if (currentArg == null) {
+          return;
+        }
       }
     }
     if (p.get$isInitializer()) {
       this._paramCode.add(p.get$name());
       fieldsSet = true;
       this._initField(newObject, p.get$name(), currentArg, p.get$definition().get$span());
     }
     else {
       var paramValue = this._scope.declareParameter(p);
       this._paramCode.add(paramValue.get$code());
@@ skipping 1020 matching lines @@
   }
   return new Value($globals.world.stringType, ("(" + Strings.join(items, " + ") + ")"), node.span);
 }
 MethodGenerator.prototype._pushBlock$1 = function($0) {
   return this._pushBlock($0, false);
 };
 MethodGenerator.prototype.run$0 = MethodGenerator.prototype.run;
 MethodGenerator.prototype.visitBinaryExpression$1 = function($0) {
   return this.visitBinaryExpression($0, false);
 };
+MethodGenerator.prototype.visitCallExpression$1 = MethodGenerator.prototype.visitCallExpression;
 MethodGenerator.prototype.visitPostfixExpression$1 = function($0) {
   return this.visitPostfixExpression($0, false);
 };
 // ********** Code for Arguments **************
 function Arguments(nodes, values) {
   this.nodes = nodes;
   this.values = values;
 }
 Arguments.Arguments$bare$factory = function(arity) {
   var values = [];
@@ skipping 1945 matching lines @@
   this.baseMethod = baseMethod;
   this.context = context;
   this.body = this.baseMethod.definition.body;
   if (this.baseMethod.get$isConstructor()) {
     this.needsTypeParams = true;
   }
 }
 MethodData.prototype.get$body = function() { return this.body; };
 MethodData.prototype.set$body = function(value) { return this.body = value; };
 MethodData.prototype.analyze = function() {
-  if (null == this.body) return;
   var ma = new MethodAnalyzer(this.baseMethod, this.body);
   ma.analyze$1(this.context);
 }
 MethodData.prototype.eval = function(method, newObject, args) {
   if ((null == method ? null != (this.baseMethod) : method !== this.baseMethod)) {
     if (!this.needsTypeParams) method = this.baseMethod;
   }
   var gen = new MethodGenerator(method, this.context);
   return gen.evalBody(newObject, args);
 }
@@ skipping 3924 matching lines @@
   return visitor.visitLambdaExpression(this);
 }
 // ********** Code for CallExpression **************
 $inherits(CallExpression, Expression);
 function CallExpression(target, arguments, span) {
   this.target = target;
   this.arguments = arguments;
   Expression.call(this, span);
 }
 CallExpression.prototype.visit = function(visitor) {
-  return visitor.visitCallExpression(this);
+  return visitor.visitCallExpression$1(this);
 }
 // ********** Code for IndexExpression **************
 $inherits(IndexExpression, Expression);
 function IndexExpression(target, index, span) {
   this.target = target;
   this.index = index;
   Expression.call(this, span);
 }
 IndexExpression.prototype.visit = function(visitor) {
   return visitor.visitIndexExpression(this);
@@ skipping 3818 matching lines @@
 }
 var const$0000 = Object.create(_DeletedKeySentinel.prototype, {});
 var const$0001 = Object.create(NoMoreElementsException.prototype, {});
 var const$0002 = Object.create(EmptyQueueException.prototype, {});
 var const$0006 = Object.create(IllegalAccessException.prototype, {});
 var const$0007 = ImmutableList.ImmutableList$from$factory([]);
 var const$0009 = new JSSyntaxRegExp("^[a-zA-Z]:/");
 var $globals = {};
 $static_init();
 main();