Fix factories in Frog to correspond to the new syntax.

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;
@@ skipping 315 matching lines @@
           if (isFinal) {
             world.error('duplicate final modifier', mod.span);
           }
           isFinal = true;
         } else {
           world.error('${mod} modifier not allowed on field', mod.span);
         }
       }
     }
     type = resolveType(definition.type, false);
-    if (isStatic && type.hasTypeParams) {
+    if (isStatic && !isFactory && 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 37 matching lines @@
   }
 
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     if (isNative && returnType != null) {
       returnType.markUsed();
       if (returnType is DefinedType) {
         // TODO(jmesserly): this handles native fields that return types like
         // "List". Is there a better solution for fields? Unlike methods we have
         // no good way to annotate them.
-        var factory_ = returnType.genericType.factory_;
-        if (factory_ != null && factory_.isNative) {
-          factory_.markUsed();
+        var defaultType = returnType.genericType.defaultType;
+        if (defaultType != null && defaultType.isNative) {
+          defaultType.markUsed();
         }
       }
     }
 
     if (isStatic) {
       // TODO(jmesserly): can we avoid generating the whole type?
       declaringType.markUsed();
 
       // Make sure to compute the value of all static fields, even if we don't
       // use this value immediately.
@@ skipping 261 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. */
   bool isLambda = false;
@@ skipping 699 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...
@@ skipping 23 matching lines @@
     }
 
     if (!isLambda) {
       library._addMember(this);
     }
   }
 
   /** Overriden to ensure that type arguments aren't used in static methods. */
   Type resolveType(TypeReference node, bool typeErrors) {
     Type t = super.resolveType(node, typeErrors);
-    if (isStatic && t is ParameterType &&
-       (typeParameters == null || !typeParameters.some((p) => p === t))) {
+    if (isStatic && !isFactory && t is ParameterType) {
       world.error('using type parameter in static context.', node.span);
     }
     return t;
   }
 }
 
 
 class MemberSet {
   final String name;
   final List<Member> members;
@@ skipping 319 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }