Fix method resolution to warn about things that don't exist on the declared type.

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 342 matching lines @@
       } else {
         writer.writeln('var ${global.name} = ${global.exp.code};');
       }
     }
   }
 
   /** Order a list of values in a Map by SourceSpan, then by name. */
   List _orderValues(Map map) {
     // TODO(jmesserly): should we copy the list?
     // Right now, the Maps are returning a copy already.
-    final values = map.getValues();
+    List values = map.getValues();
     values.sort(_compareMembers);
     return values;
   }
 
   int _compareMembers(x, y) {
     if (x.span != null && y.span != null) {
       // First compare by source span.
       int spans = x.span.compareTo(y.span);
       if (spans != 0) return spans;
     }
@@ skipping 191 matching lines @@
       : writer = new CodeWriter(), needsThis = false {
     if (enclosingMethod != null) {
       _scope = new BlockScope(this, enclosingMethod._scope);
       captures = new Set();
     } else {
       _scope = new BlockScope(this, null);
     }
     // For named lambdas, add the name to this scope so we can call it
     // recursively.
     if (enclosingMethod != null && method.name != '') {
-       _scope.create(method.name, method.functionType, method.definition);
+      MethodMember m = method; // lambdas must be MethodMembers
+      _scope.create(m.name, m.functionType, m.definition);
     }
     _usedTemps = new Set();
     _freeTemps = [];
   }
 
   // TODO(jimhug): Where does this really belong?
   MemberSet findMembers(String name) {
     return method.library._findMembers(name);
   }
 
@@ skipping 122 matching lines @@
       defWriter.exitBlock('}');
     }
     if (method.isConstructor && method.constructorName != '') {
       defWriter.writeln(
         '${method.declaringType.jsname}.${method.constructorName}\$ctor.prototype = ' +
         '${method.declaringType.jsname}.prototype;');
     }
 
     _provideOptionalParamInfo(defWriter);
 
-    if (method is MethodMember && method._providePropertySyntax) {
-      defWriter.enterBlock(
-        '${method.declaringType.jsname}.prototype.get\$${method.jsname} = function() {');
-      // TODO(jimhug): Bind not availabe in Safari, need fallback.
-      defWriter.writeln(
-        'return ${method.declaringType.jsname}.prototype.${method.jsname}.bind(this);');
-      defWriter.exitBlock('}');
+    if (method is MethodMember) {
+      MethodMember m = method;
+      if (m._providePropertySyntax) {
+        defWriter.enterBlock('${m.declaringType.jsname}.prototype'
+            + '.get\$${m.jsname} = function() {');
+        // TODO(jimhug): Bind not available in older Safari, need fallback?
+        defWriter.writeln('return ${m.declaringType.jsname}.prototype.'
+            + '${m.jsname}.bind(this);');
+        defWriter.exitBlock('}');
 
-      if (method._provideFieldSyntax) {
-        world.internalError('bound method accessed with field syntax');
+        if (m._provideFieldSyntax) {
+          world.internalError('bound m accessed with field syntax');
+        }
       }
     }
   }
 
   /**
    * Generates information about the default/named arguments into the JS code.
    * Only methods that are passed as bound methods to "var" need this. It is
    * generated to support run time stub creation.
    */
   _provideOptionalParamInfo(CodeWriter defWriter) {
-    if (method is MethodMember && method._provideOptionalParamInfo) {
-      var optNames = [];
-      var optValues = [];
-      method.genParameterValues();
-      for (var param in method.parameters) {
-        if (param.isOptional) {
-          optNames.add(param.name);
-          optValues.add(_escapeString(param.value.code));
+    if (method is MethodMember) {
+      MethodMember meth = method;
+      if (meth._provideOptionalParamInfo) {
+        var optNames = [];
+        var optValues = [];
+        meth.genParameterValues();
+        for (var param in meth.parameters) {
+          if (param.isOptional) {
+            optNames.add(param.name);
+            optValues.add(_escapeString(param.value.code));
+          }
         }
-      }
-      if (optNames.length > 0) {
-        // TODO(jmesserly): the logic for how to refer to
-        // static/instance/top-level members is duplicated all over the place.
-        // Badly needs cleanup.
-        var start = '';
-        if (method.isStatic) {
-          if (!method.declaringType.isTop) {
-            start = method.declaringType.jsname + '.';
+        if (optNames.length > 0) {
+          // TODO(jmesserly): the logic for how to refer to
+          // static/instance/top-level members is duplicated all over the place.
+          // Badly needs cleanup.
+          var start = '';
+          if (meth.isStatic) {
+            if (!meth.declaringType.isTop) {
+              start = meth.declaringType.jsname + '.';
+            }
+          } else {
+            start = meth.declaringType.jsname + '.prototype.';
           }
-        } else {
-          start = method.declaringType.jsname + '.prototype.';
+
+          optNames.addAll(optValues);
+          var optional = "['" + Strings.join(optNames, "', '") + "']";
+          defWriter.writeln('${start}${meth.jsname}.\$optional = $optional');
         }
-
-        optNames.addAll(optValues);
-        var optional = "['" + Strings.join(optNames, "', '") + "']";
-        defWriter.writeln('${start}${method.jsname}.\$optional = $optional');
       }
     }
   }
 
   writeBody() {
     var initializers = null;
     var initializedFields = null; // to check that final fields are initialized
     if (method.isConstructor) {
       initializers = [];
       initializedFields = new Set();
@@ skipping 186 matching lines @@
    */
   static String _escapeString(String text) {
     // TODO(jimhug): Use a regex for performance here.
     return text.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll(
         '\n', '\\n').replaceAll('\r', '\\r');
   }
 
   /** Visits [body] without creating a new block for a [BlockStatement]. */
   bool visitStatementsInBlock(Statement body) {
     if (body is BlockStatement) {
-      for (var stmt in body.body) {
+      BlockStatement block = body;
+      for (var stmt in block.body) {
         stmt.visit(this);
       }
     } else {
       if (body != null) body.visit(this);
     }
     return false;
   }
 
   _pushBlock([bool reentrant = false]) {
     _scope = new BlockScope(this, _scope, reentrant);
@@ skipping 546 matching lines @@
     meth.generator.writeDefinition(w, node);
 
     return new Value(meth.functionType, w.text);
   }
 
   visitCallExpression(CallExpression node) {
     var target;
     var position = node.target;
     var name = '\$call';
     if (node.target is DotExpression) {
-      target = node.target.self.visit(this);
-      name = node.target.name.name;
-      position = node.target.name;
+      DotExpression dot = node.target;
+      target = dot.self.visit(this);
+      name = dot.name.name;
+      position = dot.name;
     } else if (node.target is VarExpression) {
-      name = node.target.name.name;
+      VarExpression varExpr = node.target;
+      name = varExpr.name.name;
       var meth = method.declaringType.resolveMember(name);
       if (meth != null) {
         target = _makeThisOrType();
-        return meth.invoke(this, node.target, target,
+        return meth.invoke(this, varExpr, target,
             _makeArgs(node.arguments));
       }
       // Look for members of the top-level type (or imported libs).
-      meth = method.declaringType.library.lookup(name, node.target.span);
+      meth = method.declaringType.library.lookup(name, varExpr.span);
       if (meth != null) {
-        return meth.invoke(this, node.target, null,
-            _makeArgs(node.arguments));
+        return meth.invoke(this, varExpr, null, _makeArgs(node.arguments));
       }
 
       name = '\$call';
-      target = node.target.visit(this);
+      target = varExpr.visit(this);
     } else {
       target = node.target.visit(this);
     }
 
     return target.invoke(this, name, position, _makeArgs(node.arguments));
   }
 
   visitIndexExpression(IndexExpression node) {
     var target = visitValue(node.target);
     var index = visitValue(node.index);
@@ skipping 647 matching lines @@
       result.add(new Value(world.varType, '\$$i', false, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, false, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }