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

dart/frog/analyze.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * A simple code analyzer for Dart.
  *
  * Currently used to ensure all concrete generic types are visited.
  * Also performs all static type checks - so these don't need to be
  * done in later phases.
  *
  * Ultimately, this should include abstract interpreter work.  This will
  * result in an interesting split beteen this class and MethodGenerator
  * which should be turned into nothing more than a code generator.
  */
 // TODO(jimhug): This class shares too much code with MethodGenerator.
 class MethodAnalyzer implements TreeVisitor {
   MethodMember method;
   Statement body;
 
   CallFrame _frame;
 
   /**
    * Track whether or not [body] refers to any type parameters from the
    * enclosing type to advise future code generation and analysis.
    */
   bool hasTypeParams = false;
+  bool visitingInitializers = false;
 
   MethodAnalyzer(this.method, this.body);
 
   // TODO(jimhug): Type issue with requiring CallFrame here...
   void analyze(CallFrame context) {
     var thisValue;
     // TODO(jimhug): Move Constructor analysis to here and below.
 
     if (context != null) {
       thisValue = context.thisValue;
     } else {
       thisValue = new PureStaticValue(method.declaringType, null);
     }
     var values = [];
     for (var p in method.parameters) {
       values.add(new PureStaticValue(p.type, null));
     }
     var args = new Arguments(null, values);
 
     _frame = new CallFrame(this, method, thisValue, args, context);
     _bindArguments(_frame.args);
-    body.visit(this);
+
+    final declaredInitializers = method.definition.dynamic.initializers;

[kasperl, 2012/02/03 15:39:20]

Add a comment here that explains how this is dealt with. Explain that your
changing the behavior of visitCallExpression to realize when you're in the
middle of visiting an initializer expression (alternatively you could add
another visitor but that's probably overkill).

[ngeoffray, 2012/02/06 11:50:31]

Done.

+    var initializerCall = null;
+    if (declaredInitializers != null) {
+      visitingInitializers = true;
+      for (var init in declaredInitializers) {
+        if (init is CallExpression) {

[kasperl, 2012/02/03 15:39:20]

How bad would it be to add an optional parameter to visitCallExpression
[inInitializer=false] and call that visit function from here with inInitializer:
true? That way you wouldn't need to add extra state to this visitor.

[ngeoffray, 2012/02/06 11:50:31]

Done.

+          init.visit(this);;

[kasperl, 2012/02/03 15:39:20]

;; -> ;

[ngeoffray, 2012/02/06 11:50:31]

Done.

+        }
+      }
+      visitingInitializers = false;
+    }
+
+    if (body != null) body.visit(this);
   }
 
   /* Checks whether or not a particular TypeReference Node includes references
    * to type parameters. */
   bool _hasTypeParams(node) {
     if (node is NameTypeReference) {
       var name = node.name.name;
       return (method.declaringType.lookupTypeParam(name) != null);
     } else if (node is GenericTypeReference) {
       for (var typeArg in node.typeArguments) {
@@ skipping 327 matching lines @@
   visitLambdaExpression(LambdaExpression node) {
     var name = (node.func.name != null) ? node.func.name.name : '';
 
     MethodMember meth = _makeLambdaMethod(name, node.func);
     // TODO(jimhug): Worry about proper scope for recursive lambda.
     meth.methodData.analyze();
 
     return _frame._makeValue(world.functionType, node);
   }
 
+  analyzeThisOrSuperConstructorCall(CallExpression node,

[kasperl, 2012/02/03 15:39:20]

analyzeInitializerConstructorCall instead? In this context, they are both
constructor calls.

[ngeoffray, 2012/02/06 11:50:31]

Done.

+                                    Expression receiver,
+                                    String name) {
+    var type = _frame.method.declaringType;
+    if (receiver is SuperExpression) {
+      type = type.parent;
+    }
+    var member = type.getConstructor(name);
+    if (member !== null) {
+      return member.invoke(_frame, node, _frame.makeThisValue(node),
+                           _visitArgs(node.arguments));
+    } else {
+      world.warning('cannot find "$name"', node.span);

[kasperl, 2012/02/03 15:39:20]

How does this look if name is the empty string? Maybe you should pass in null
for name in that case instead and deal with it?

[ngeoffray, 2012/02/06 11:50:31]

Done.

+      return _frame._makeValue(world.varType, node);
+    }
+  }
+
+  bool isThisOrSuper(Expression node) {
+    return node is ThisExpression || node is SuperExpression;
+  }
+
   Value visitCallExpression(CallExpression node) {
     var target;
     var position = node.target;
     var name = ':call';
     if (node.target is DotExpression) {
       DotExpression dot = node.target;
       target = dot.self.visit(this);
       name = dot.name.name;
-      position = dot.name;
+      if (isThisOrSuper(dot.self) && visitingInitializers) {
+        return analyzeThisOrSuperConstructorCall(node, dot.self, name);
+      } else {
+        position = dot.name;
+      }
+    } else if (isThisOrSuper(node.target) && visitingInitializers) {
+      return analyzeThisOrSuperConstructorCall(node, node.target, '');
     } else if (node.target is VarExpression) {
       VarExpression varExpr = node.target;
       name = varExpr.name.name;
       // First check in block scopes.
       target = _frame.lookup(name);
       if (target != null) {
         return target.get(position).invoke(_frame, ':call', node,
           _visitArgs(node.arguments));
       }
 
@@ skipping 325 matching lines @@
     for (var item in node.pieces) {
       var val = visitValue(item);
       var sval = val.invoke(_frame, 'toString', item, Arguments.EMPTY);
       ret = ret.binop(TokenKind.ADD, sval, _frame, item);
     }
     return _frame._makeValue(world.stringType, node); //???ret;
     */
   }
 }