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

frog/member.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.
 
 /** A formal parameter to a [Method]. */
 class Parameter {
   FormalNode definition;
 
   String name;
   Type type;
@@ skipping 97 matching lines @@
   Library get library() => declaringType.library;
 
   bool get isPrivate() => name.startsWith('_');
 
   bool get isConstructor() => false;
   bool get isField() => false;
   bool get isMethod() => false;
   bool get isProperty() => false;
   bool get isAbstract() => false;
 
+  // TODO(jmesserly): these only makes sense on methods, but because of
+  // ConcreteMember we need to support them on Member.
+  bool get isConst() => false;
+  bool get isFactory() => false;
+
   bool get prefersPropertySyntax() => true;
   bool get requiresFieldSyntax() => false;
 
   bool get isNative() => false;
   String get constructorName() =>
       world.internalError('can not be a constructor', span);
 
   void provideFieldSyntax() => world.internalError('can not be field', span);
   void providePropertySyntax() =>
-    world.internalError('can not be property', span);
+      world.internalError('can not be property', span);
+
+  Definition get initDelegate() =>
+      world.internalError('cannot have initializers', span);
+  Definition set initDelegate(ctor) =>
+      world.internalError('cannot have initializers', span);
 
   Definition get definition() => null;
 
   List<Parameter> get parameters() => [];
 
   // TODO(jimhug): Fix these names once get/set are truly pseudo-keywords.
   // TODO(jmesserly): isDynamic isn't a great name for this, something better?
   abstract Value get_(MethodGenerator context, Node node, Value target,
       [bool isDynamic]);
 
@@ skipping 24 matching lines @@
 
   String get generatedFactoryName() {
     assert(this.isFactory);
     String prefix = '${declaringType.jsname}.${constructorName}\$';
     if (name == '') {
       return '${prefix}factory';
     } else {
       return '${prefix}$name\$factory';
     }
   }
+
+  Type resolveType(TypeReference node, bool isRequired) {
+    var type = declaringType.resolveType(node, isRequired);
+    if (isStatic && type.hasTypeParams) {
+      // TODO(jimhug): Is this really so hard?
+      world.error('using type parameter in static context',
+        node.span);
+    }
+    return type;
+  }
 }
 
 
 /**
  * Types are treated as first class members of their library's top type.
  */
 // TODO(jmesserly): perhaps Type should extend Member, but that can get
 // complicated.
 class TypeMember extends Member {
   final DefinedType type;
 
   TypeMember(DefinedType type)
       : super(type.name, type.library.topType),
         this.type = type;
 
   SourceSpan get span() => type.definition.span;
 
   bool get isStatic() => true;
 
   // If this really becomes first class, this should return typeof(Type)
-  Type get returnType() => world.isVar;
+  Type get returnType() => world.varType;
 
   bool canInvoke(MethodGenerator context, Arguments args) => false;
   bool get canGet() => true;
   bool get canSet() => false;
 
   void resolve(Type inType) {}
 
   Value get_(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     assert(target == null || target.type.isTop);
@@ skipping 156 matching lines @@
       if (isFinal) {
         return cv;
       }
       if (declaringType.isTop) {
         return new Value(type, '$jsname');
       } else {
         return new Value(type, '${declaringType.jsname}.$jsname');
       }
     } else if (target.isConst && isFinal) {
       // take advantage of consts and retrieve the value directly if possible
-      var constTarget = target is GlobalValue ? target.exp : target;
+      var constTarget = target is GlobalValue ? target.dynamic.exp : target;
       if (constTarget is ConstObjectValue) {
         return constTarget.fields[name];
       } else if (constTarget.type == world.stringType && name == 'length') {
         return new Value(type, '${constTarget.actualValue.length}');
       }
     }
     return new Value(type, '${target.code}.$jsname');
   }
 
   Value set_(MethodGenerator context, Node node, Value target, Value value,
@@ skipping 71 matching lines @@
       }
       return target.invokeNoSuchMethod(context, 'set:$name', node,
         new Arguments(null, [value]));
     }
     return setter.invoke(context, node, target, new Arguments(null, [value]),
       isDynamic);
   }
 
   addFromParent(Member parentMember) {
     // TODO(jimhug): Egregious Hack!
+    PropertyMember parent;
     if (parentMember is ConcreteMember) {
-      parentMember = parentMember.baseMember;
+      ConcreteMember c = parentMember;
+      parent = c.baseMember;
+    } else {
+      parent = parentMember;
     }
 
-    if (getter == null) getter = parentMember.getter;
-    if (setter == null) setter = parentMember.setter;
+    if (getter == null) getter = parent.getter;
+    if (setter == null) setter = parent.setter;
   }
 
   resolve(Type inType) {
     if (getter != null) getter.resolve(inType);
     if (setter != null) setter.resolve(inType);
 
     library._addMember(this);
   }
 }
 
@@ skipping 16 matching lines @@
         parameters.add(p);
       }
     }
   }
 
   SourceSpan get span() => baseMember.span;
 
   bool get isStatic() => baseMember.isStatic;
   bool get isAbstract() => baseMember.isAbstract;
   bool get isConst() => baseMember.isConst;
+  bool get isFactory() => baseMember.isFactory;
 
   String get jsname() => baseMember.jsname;
   set jsname(String name) =>
     world.internalError('bad set of jsname on ConcreteMember');
 
-  bool get isFactory() => baseMember.isFactory;
 
   bool get canGet() => baseMember.canGet;
   bool get canSet() => baseMember.canSet;
   bool canInvoke(MethodGenerator context, Arguments args) =>
     baseMember.canInvoke(context, args);
 
   bool get isField() => baseMember.isField;
   bool get isMethod() => baseMember.isMethod;
   bool get isProperty() => baseMember.isProperty;
 
@@ skipping 90 matching lines @@
   bool get isMethod() => !isConstructor;
 
   bool get isNative() => definition.body is NativeStatement;
 
   bool get canGet() => false; // TODO(jimhug): get bound method support.
   bool get canSet() => false;
 
   SourceSpan get span() => definition == null ? null : definition.span;
 
   String get constructorName() {
-    if (definition.returnType == null) return '';
+    NameTypeReference returnType = definition.returnType;
+    if (returnType == null) return '';
 
     // TODO(jmesserly): make this easier?
-    if (definition.returnType.names != null) {
-      return definition.returnType.names[0].name;
-    } else if (definition.returnType.name != null) {
-      return definition.returnType.name.name;
+    if (returnType.names != null) {
+      return returnType.names[0].name;
+    } else if (returnType.name != null) {
+      return returnType.name.name;
     }
     world.internalError('no valid constructor name', definition.span);
   }
 
   Type get functionType() {
     if (_functionType == null) {
       _functionType = library.getOrAddFunctionType(name,
         definition, declaringType);
       // TODO(jimhug): Better resolution checks.
       if (parameters == null) {
@@ skipping 43 matching lines @@
   int indexOfParameter(String name) {
     for (int i = 0; i < parameters.length; i++) {
       final p = parameters[i];
       if (p.isOptional && p.name == name) {
         return i;
       }
     }
     return -1;
   }
 
-  Type resolveType(TypeReference node, bool isRequired) {
-    var type = declaringType.resolveType(node, isRequired);
-    if (isStatic && type.hasTypeParams) {
-      // TODO(jimhug): Is this really so hard?
-      world.error('using type parameter in static context',
-        node.span);
-    }
-    return type;
-  }
-
   bool get prefersPropertySyntax() => true;
   bool get requiresFieldSyntax() => false;
 
   void provideFieldSyntax() => _provideFieldSyntax = true;
   void providePropertySyntax() => _providePropertySyntax = true;
 
   Value set_(MethodGenerator context, Node, Value target, Value value,
       [bool isDynamic=false]) {
     world.error('can not set method', definition.span);
   }
@@ skipping 194 matching lines @@
         return new Value(returnType, '$jsname($argsString)');
       }
       return new Value(returnType,
         '${declaringType.jsname}.$jsname($argsString)');
     }
 
     var code = '${target.code}.$jsname($argsString)';
     // optimize expressions which we know statically their value.
     if (target.isConst) {
       if (target is GlobalValue) {
-        target = target.exp;
+        target = target.dynamic.exp; // TODO: an inline "cast" would be nice.
       }
       if (name == 'get\$length') {
         if (target is ConstListValue || target is ConstMapValue) {
-          code = '${target.values.length}';
+          code = '${target.dynamic.values.length}';
         }
       } else if (name == 'isEmpty') {
         if (target is ConstListValue || target is ConstMapValue) {
-          code = '${target.values.isEmpty()}';
+          code = '${target.dynamic.values.isEmpty()}';
         }
       }
     }
 
     // TODO(jmesserly): factor this better
     if (name == 'get\$typeName' && declaringType.library == world.dom) {
       world.gen.corejs.useTypeNameOf = true;
     }
 
     return new Value(returnType, code);
   }
 
-  Value _invokeConstructor(MethodGenerator context, Node node, Value target,
-      Arguments args, argsString) {
+  Value _invokeConstructor(MethodGenerator context, Node node,
+      Value target, Arguments args, argsString) {
     declaringType.markUsed();
 
     if (target != null) {
       // initializer call to another constructor
       var code = (constructorName != '')
           ? '${declaringType.jsname}.${constructorName}\$ctor.call($argsString)'
           : '${declaringType.jsname}.call($argsString)';
       return new Value(declaringType, code);
     } else {
       var code = (constructorName != '')
           ? 'new ${declaringType.jsname}.${constructorName}\$ctor($argsString)'
           : 'new ${declaringType.jsname}($argsString)';
-      if (isConst && node.isConst) {
+      // TODO(jmesserly): using the "node" here feels really hacky
+      if (isConst && node is NewExpression && node.dynamic.isConst) {
         return _invokeConstConstructor(node, code, target, args);
       } else {
         return new Value(declaringType, code);
       }
     }
   }
 
   /**
    * Special handling for const constructors so that so that:
    * [: const B() === const B.a(0, 1) === const B.b(0) :]
@@ skipping 66 matching lines @@
             // Super-call: embed the value the super class fields.
             if (value is GlobalValue) {
               value = value.exp;
             }
             for (var fname in value.fields.getKeys()) {
               fields[fname] = value.fields[fname];
             }
           }
         } else {
           // Normal field initializer assignment.
-          var fname = init.x.name.name;
-          var val = generator.visitValue(init.y);
+          BinaryExpression assign = init;
+          VarExpression x = assign.x;
+          var fname = x.name.name;
+          var val = generator.visitValue(assign.y);
           fields[fname] = val;
         }
       }
 
       generator._popBlock();
     }
 
     // Add default values only if they weren't overriden in the constructor.
     for (var f in declaringType.members.getValues()) {
       if (f is FieldMember && !f.isStatic && f.value != null
@@ skipping 496 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }