Clean up resynthesis of typeArguments.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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.
 
 library summary_resynthesizer;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/summary/format.dart';
 
 /**
  * Callback used by [SummaryResynthesizer] to obtain the prelinked summary for
  * a given URI.
  */
 typedef PrelinkedLibrary GetPrelinkedSummaryCallback(String uri);
 
 /**
  * Callback used by [SummaryResynthesizer] to obtain the unlinked summary for a
  * given URI.
  */
 typedef UnlinkedUnit GetUnlinkedSummaryCallback(String uri);
 
 /**
- * Specialization of [FunctionTypeImpl] used for function types resynthesized
- * from summaries.
- */
-class ResynthesizedFunctionTypeImpl extends FunctionTypeImpl
-    with ResynthesizedType {
-  final SummaryResynthesizer summaryResynthesizer;
-
-  ResynthesizedFunctionTypeImpl(
-      FunctionTypeAliasElement element, String name, this.summaryResynthesizer)
-      : super.elementWithName(element, name);
-
-  int get _numTypeParameters {
-    FunctionTypeAliasElement element = this.element;
-    return element.typeParameters.length;
-  }
-}
-
-/**
- * Specialization of [InterfaceTypeImpl] used for interface types resynthesized
- * from summaries.
- */
-class ResynthesizedInterfaceTypeImpl extends InterfaceTypeImpl
-    with ResynthesizedType {
-  final SummaryResynthesizer summaryResynthesizer;
-
-  ResynthesizedInterfaceTypeImpl(
-      ClassElement element, String name, this.summaryResynthesizer)
-      : super.elementWithName(element, name);
-
-  int get _numTypeParameters => element.typeParameters.length;
-}
-
-/**
- * Common code for types resynthesized from summaries.  This code takes care of
- * filling in the appropriate number of copies of `dynamic` when it is queried
- * for type parameters on a bare type reference (i.e. it converts `List` to
- * `List<dynamic>`).
- */
-abstract class ResynthesizedType implements DartType {
-  /**
-   * The type arguments, if known.  Otherwise `null`.
-   */
-  List<DartType> _typeArguments;
-
-  SummaryResynthesizer get summaryResynthesizer;
-
-  List<DartType> get typeArguments {
-    if (_typeArguments == null) {
-      // Default to replicating "dynamic" as many times as the class element
-      // requires.
-      _typeArguments = new List<DartType>.filled(
-          _numTypeParameters, summaryResynthesizer.typeProvider.dynamicType);
-    }
-    return _typeArguments;
-  }
-
-  int get _numTypeParameters;
-}
-
-/**
  * Implementation of [ElementResynthesizer] used when resynthesizing an element
  * model from summaries.
  */
 class SummaryResynthesizer extends ElementResynthesizer {
   /**
    * Callback used to obtain the prelinked summary for a given URI.
    */
   final GetPrelinkedSummaryCallback getPrelinkedSummary;
 
   /**
@@ skipping 707 matching lines @@
         if (referenceResolution.unit != 0) {
           String uri = unlinkedUnits[0].publicNamespace.parts[
               referenceResolution.unit - 1].uri;
           Source partSource =
               summaryResynthesizer.sourceFactory.resolveUri(librarySource, uri);
           partUri = partSource.uri.toString();
         } else {
           partUri = referencedLibraryUri;
         }
       }
-      ResynthesizedType resynthesizedType;
       ElementLocationImpl location = new ElementLocationImpl.con3(
           <String>[referencedLibraryUri, partUri, reference.name]);
+      List<DartType> typeArguments = const <DartType>[];
+      if (referenceResolution.numTypeParameters != 0) {
+        typeArguments = <DartType>[];
+        for (int i = 0; i < referenceResolution.numTypeParameters; i++) {
+          if (i < type.typeArguments.length) {
+            typeArguments.add(buildType(type.typeArguments[i]));
+          } else {
+            typeArguments.add(summaryResynthesizer.typeProvider.dynamicType);
+          }
+        }
+      }
       switch (referenceResolution.kind) {
         case PrelinkedReferenceKind.classOrEnum:
-          resynthesizedType = new ResynthesizedInterfaceTypeImpl(
+          return new InterfaceTypeImpl.elementWithNameAndArgs(
               new ClassElementHandle(summaryResynthesizer, location),
               reference.name,
-              summaryResynthesizer);
-          break;
+              typeArguments);
         case PrelinkedReferenceKind.typedef:
-          resynthesizedType = new ResynthesizedFunctionTypeImpl(
+          return new FunctionTypeImpl.elementWithNameAndArgs(
               new FunctionTypeAliasElementHandle(
                   summaryResynthesizer, location),
               reference.name,
-              summaryResynthesizer);
-          break;
+              typeArguments);
         default:
           // TODO(paulberry): figure out how to handle this case (which should
           // only occur in the event of erroneous code).
           throw new UnimplementedError();
       }
-      if (type.typeArguments.isNotEmpty) {
-        resynthesizedType._typeArguments =
-            type.typeArguments.map(buildType).toList();
-      }
-      return resynthesizedType;
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     try {
       currentTypeParameters =
@@ skipping 112 matching lines @@
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
     unlinkedUnit = null;
   }
 }