Fix bug 578

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;
+  Member method;
 
   String name;
   Type type;
   bool isInitializer = false;
 
   Value value;
 
-  Parameter(this.definition);
+  Parameter(this.definition, this.method);
 
-  resolve(Member method, Type inType) {
+  resolve() {
     name = definition.name.name;
     if (name.startsWith('this.')) {
       name = name.substring(5);
       isInitializer = true;
     }
 
-    type = inType.resolveType(definition.type, false);
+    type = method.resolveType(definition.type, false);
 
-    if (method.isStatic && type.hasTypeParams) {
+    if (method.isStatic && method.typeParameters === null && type.hasTypeParams) {
       world.error('using type parameter in static context', definition.span);
     }
 
     if (definition.value != null) {
       // To match VM, detect cases where value was not actually specified in
       // code and don't signal errors.
       // TODO(jimhug): Clean up after issue #352 is resolved.
       if (definition.value is NullExpression &&
           definition.value.span.start == definition.span.start) {
         return;
@@ skipping 18 matching lines @@
   genValue(MethodMember method, MethodGenerator context) {
     if (definition.value == null || value != null) return;
 
     if (context == null) { // interface method
       context = new MethodGenerator(method, null);
     }
     value = definition.value.visit(context);
     value = value.convertTo(context, type, definition.value);
   }
 
-  Parameter copyWithNewType(Type newType) {
-    var ret = new Parameter(definition);
+  Parameter copyWithNewType(Member newMethod, Type newType) {
+    var ret = new Parameter(definition, newMethod);
     ret.type = newType;
     ret.name = name;
     ret.isInitializer = isInitializer;
     return ret;
   }
 
   bool get isOptional() => definition != null && definition.value != null;
 }
 
 
-interface Named {
-  String get name();
-  Library get library();
-  bool get isNative();
-  String get jsname();
-  set jsname(String name);
-
-  SourceSpan get span();
-}
-
-class Member implements Named {
-  final String name;
+class Member extends Element {
   final Type declaringType;
 
-  String _jsname;
-
   bool isGenerated;
   MethodGenerator generator;
 
-  Member(this.name, this.declaringType): isGenerated = false;
-
-  abstract SourceSpan get span();
+  Member(String name, Type declaringType)
+    : isGenerated = false, this.declaringType = declaringType,
+      super(name, declaringType);
 
   abstract bool get isStatic();
   abstract Type get returnType();
 
   abstract bool get canGet();
   abstract bool get canSet();
 
-  abstract void resolve(Type inType);
-
-  String get jsname() => _jsname == null ? name : _jsname;
-
-  set jsname(String name) => _jsname = name;
-
   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;
 
@@ skipping 82 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;
-  }
-
   int hashCode() => (declaringType.hashCode() << 4) ^ name.hashCode();
 }
 
 
 /**
  * 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.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]) {
     return new Value.type(type, node.span);
   }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     world.error('cannot set type', node.span);
   }
 
@@ skipping 57 matching lines @@
 
   SourceSpan get span() => definition == null ? null : definition.span;
 
   Type get returnType() => type;
 
   bool get canGet() => true;
   bool get canSet() => !isFinal;
 
   bool get isField() => true;
 
-  resolve(Type inType) {
+  resolve() {
     isStatic = declaringType.isTop;
     isFinal = false;
     if (definition.modifiers != null) {
       for (var mod in definition.modifiers) {
         if (mod.kind == TokenKind.STATIC) {
           if (isStatic) {
             world.error('duplicate static modifier', mod.span);
           }
           isStatic = true;
         } else if (mod.kind == TokenKind.FINAL) {
           if (isFinal) {
             world.error('duplicate final modifier', mod.span);
           }
           isFinal = true;
         } else {
           world.error('${mod} modifier not allowed on field', mod.span);
         }
       }
     }
-    type = inType.resolveType(definition.type, false);
+    type = resolveType(definition.type, false);
     if (isStatic && type.hasTypeParams) {
       world.error('using type parameter in static context',
         definition.type.span);
     }
 
     if (isStatic && isFinal && value == null) {
       world.error('static final field is missing initializer', span);
     }
 
     library._addMember(this);
@@ skipping 166 matching lines @@
       ConcreteMember c = parentMember;
       parent = c.baseMember;
     } else {
       parent = parentMember;
     }
 
     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);
+  resolve() {
+    if (getter != null) getter.resolve();
+    if (setter != null) setter.resolve();
 
     library._addMember(this);
   }
 }
 
 
 class ConcreteMember extends Member {
   final Member baseMember;
   Type returnType;
   List<Parameter> parameters;
 
   ConcreteMember(String name, ConcreteType declaringType, this.baseMember)
       : super(name, declaringType) {
     parameters = [];
     returnType = baseMember.returnType.resolveTypeParams(declaringType);
-    // TODO(jimhug): Optimize not creating new array if new param types.
+    // TODO(jimhug): Optimize not creating new array if no new param types.
     for (var p in baseMember.parameters) {
       var newType = p.type.resolveTypeParams(declaringType);
       if (newType != p.type) {
-        parameters.add(p.copyWithNewType(newType));
+        parameters.add(p.copyWithNewType(this, newType));
       } else {
         parameters.add(p);
       }
     }
   }
 
   SourceSpan get span() => baseMember.span;
 
   bool get isStatic() => baseMember.isStatic;
   bool get isAbstract() => baseMember.isAbstract;
@@ skipping 71 matching lines @@
   }
 }
 
 
 /** Represents a Dart method or top-level function. */
 class MethodMember extends Member {
   FunctionDefinition definition;
   Type returnType;
   List<Parameter> parameters;
 
+  // Could support generic methods in general.  Right now only used for
+  // strange corner case of factory methods for generic types.
+  List<ParameterType> typeParameters;
+
 
   Type _functionType;
   bool isStatic = false;
   bool isAbstract = false;
 
   // Note: these two modifiers are only legal on constructors
   bool isConst = false;
   bool isFactory = false;
 
   /** True if this is a function defined inside another method. */
@@ skipping 21 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() {
-    NameTypeReference returnType = definition.returnType;
+    var returnType = definition.returnType;
     if (returnType == null) return '';
+    if (returnType is GenericTypeReference) {
+      return '';
+    }
 
     // TODO(jmesserly): make this easier?
     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);
+      _functionType = library.getOrAddFunctionType(declaringType, name, definition);
       // TODO(jimhug): Better resolution checks.
       if (parameters == null) {
-        resolve(declaringType);
+        resolve();
       }
     }
     return _functionType;
   }
 
   bool override(Member other) {
     if (!super.override(other)) return false;
 
     // methods can only override other methods
     if (other.isMethod) {
@@ skipping 132 matching lines @@
 
   /**
    * Invokes this method on the given [target] with the given [args].
    * [node] provides a [SourceSpan] for any error messages.
    */
   Value invoke(MethodGenerator context, Node node, Value target,
       Arguments args, [bool isDynamic=false]) {
     // TODO(jimhug): Fix this hack for ensuring a method is resolved.
     if (parameters == null) {
       world.info('surprised to need to resolve: ${declaringType.name}.$name');
-      this.resolve(declaringType);
+      resolve();
     }
 
     declaringType.genMethod(this);
 
     if (isStatic || isFactory) {
       // TODO(sigmund): can we avoid generating the entire type, but only what
       // we need?
       declaringType.markUsed();
     }
 
@@ skipping 334 matching lines @@
           var value = '${val0}${val1}';
           value = '"' + value.replaceAll('"', '\\"') + '"';
           return new EvaluatedValue(world.stringType, value, value, node.span);
         }
 
         // Ensure we generate toString on the right side
         args.values[0].invoke(context, 'toString', node, Arguments.EMPTY);
         return new Value(declaringType, '${target.code} + ${argsCode[0]}',
           node.span);
       }
-    } else if (declaringType.isNativeType) {
+    } else if (declaringType.isNative) {
       if (name == '\$index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
         return new Value(returnType, '${target.code}[${argsCode[0]}]', node.span);
       } else if (name == '\$setindex') {
         return new Value(returnType,
           '${target.code}[${argsCode[0]}] = ${argsCode[1]}', node.span);
       }
     }
 
@@ skipping 38 matching lines @@
       world.gen.corejs.useSetIndex = true;
     }
 
     // Fall back to normal method invocation.
     var argsString = Strings.join(argsCode, ', ');
     return new Value(inferredResult, '${target.code}.$jsname($argsString)',
       node.span);
   }
 
 
-  resolve(Type inType) {
+  resolve() {
     // TODO(jimhug): cut-and-paste-and-edit from Field.resolve
-    isStatic = inType.isTop;
+    isStatic = declaringType.isTop;
     isConst = false;
     isFactory = false;
     isAbstract = !declaringType.isClass;
     if (definition.modifiers != null) {
       for (var mod in definition.modifiers) {
         if (mod.kind == TokenKind.STATIC) {
           if (isStatic) {
             world.error('duplicate static modifier', mod.span);
           }
           isStatic = true;
@@ skipping 20 matching lines @@
         } else {
           world.error('${mod} modifier not allowed on method', mod.span);
         }
       }
     }
 
     if (isFactory) {
       isStatic = true;
     }
 
+    if (definition.typeParameters != null) {
+      if (!isFactory) {
+        world.error(
+          'Only factories are allowed to have explicit type parameters',
+          definition.typeParameters[0].span);
+      } else {
+        typeParameters = definition.typeParameters;
+        for (var tp in definition.typeParameters) {
+          tp.enclosingElement = this;
+          tp.resolve();
+        }
+      }
+    }
+
     // TODO(jimhug): need a better annotation for being an operator method
     if (isOperator && isStatic && !isCallMethod) {
       world.error('operator method may not be static "${name}"', span);
     }
 
     if (isAbstract) {
       if (definition.body != null &&
           declaringType.definition is! FunctionTypeDefinition) {
         // TODO(jimhug): Creating function types for concrete methods is
         //   steadily feeling uglier...
         world.error('abstract method can not have a body', span);
       }
       if (isStatic &&
           declaringType.definition is! FunctionTypeDefinition) {
         world.error('static method can not be abstract', span);
       }
     } else {
       if (definition.body == null && !isConstructor) {
         world.error('method needs a body', span);
       }
     }
 
-    if (isConstructor) {
+    if (isConstructor && !isFactory) {
       returnType = declaringType;
     } else {
-      // TODO(jimhug): Unify this check and the below with method's
-      //   resolveType method - requires cleaning up inType stuff.
-      returnType = inType.resolveType(definition.returnType, false);
-
-      if (isStatic && returnType.hasTypeParams) {
-        world.error('using type parameter in static context',
-          definition.returnType.span);
-      }
+      returnType = resolveType(definition.returnType, false);
     }
     parameters = [];
     for (var formal in definition.formals) {
-      var param = new Parameter(formal);
-      param.resolve(this, inType);
+      // TODO(jimhug): Clean up construction of Parameters.
+      var param = new Parameter(formal, this);
+      param.resolve();
       parameters.add(param);
     }
 
     if (!isLambda) {
       library._addMember(this);
     }
   }
-
-  Type findTypeVariable(TypeReference node, bool isRequired) {
-    if (!this.isFactory || node is! NameTypeReference) {
-      return super.resolveType(node, isRequired);
-    } else {
-      // TODO(ahe): We cannot find any type variables as they aren't
-      // recorded. So we turn this in to a warning instead.
-      return super.resolveType(node, false);
-    }
-  }
-
-  Type resolveType(TypeReference node, bool isRequired) {
-    if (node !== null && this.isFactory && isRequired) {
-      if (node is GenericTypeReference) {
-        // TODO(ahe): This is bascially a copy of code in
-        // DefinedType.resolveType. More checks should be performed,
-        // such as bounds check, but the code is structured in a way
-        // that makes this hard.
-        GenericTypeReference genericReference = node;
-        var baseType = super.resolveType(genericReference.baseType, isRequired);
-        var typeArguments = [];
-        for (TypeReference ref in genericReference.typeArguments) {
-          // TODO(ahe): This let us ignore T in new Foo<T>, but not in
-          // new Foo<Foo<T>>.
-          typeArguments.add(findTypeVariable(ref, isRequired));
-        }
-        node.type = baseType.getOrMakeConcreteType(typeArguments);
-        return node.type;
-      }
-    }
-    return super.resolveType(node, isRequired);
-  }
 }
 
 
 class MemberSet {
   final String name;
   final List<Member> members;
   final String jsname;
   final bool isVar;
 
   MemberSet(Member member, [bool isVar=false]):
@@ skipping 299 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }