Add typedef support to summary linker.

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

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 169 matching lines @@
     return result;
   } else if (type is TypeParameterType) {
     TypeParameterElementForLink element = type.element;
     result.paramReference =
         typeParameterContext.typeParameterNestingLevel - element.nestingLevel;
     return result;
   } else if (type is FunctionType) {
     Element element = type.element;
     if (element is FunctionElementForLink_FunctionTypedParam) {
       result.reference =
-          compilationUnit.addReference(element.innermostExecutable);
+          compilationUnit.addReference(element.typeParameterContext);
       result.implicitFunctionTypeIndices = element.implicitFunctionTypeIndices;
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
     }
     if (element is TopLevelFunctionElementForLink) {
       result.reference = compilationUnit.addReference(element);
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
     }
     if (element is MethodElementForLink) {
       result.reference = compilationUnit.addReference(element);
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
     }
+    if (element is FunctionTypeAliasElementForLink) {
+      result.reference = compilationUnit.addReference(element);
+      _storeTypeArguments(
+          type.typeArguments, result, compilationUnit, typeParameterContext);
+      return result;
+    }
     // TODO(paulberry): implement other cases.
     throw new UnimplementedError('${element.runtimeType}');
   }
   // TODO(paulberry): implement other cases.
   throw new UnimplementedError('${type.runtimeType}');
 }
 
 /**
  * Store the given [typeArguments] in [encodedType], using [compilationUnit] and
  * [typeParameterContext] to serialize them.
@@ skipping 180 matching lines @@
         _accessors.add(field.getter);
         if (!field.isConst && !field.isFinal) {
           _accessors.add(field.setter);
         }
       }
     }
     return _accessors;
   }
 
   @override
+  CompilationUnitElementForLink get compilationUnit => enclosingElement;
+
+  @override
   List<ConstructorElementForLink> get constructors {
     if (_constructors == null) {
       _constructors = <ConstructorElementForLink>[];
       for (UnlinkedExecutable unlinkedExecutable
           in _unlinkedClass.executables) {
         if (unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
           _constructors
               .add(new ConstructorElementForLink(this, unlinkedExecutable));
         }
       }
@@ skipping 265 matching lines @@
    * The absolute URI of this compilation unit.
    */
   final String _absoluteUri;
 
   List<ClassElementForLink_Class> _types;
   Map<String, ReferenceableElementForLink> _containedNames;
   List<TopLevelVariableElementForLink> _topLevelVariables;
   List<ClassElementForLink_Enum> _enums;
   List<TopLevelFunctionElementForLink> _functions;
   List<PropertyAccessorElementForLink> _accessors;
+  List<FunctionTypeAliasElementForLink> _functionTypeAliases;
 
   /**
    * Index of this unit in the list of units in the enclosing library.
    */
   final int unitNum;
 
   CompilationUnitElementForLink(UnlinkedUnit unlinkedUnit, this.unitNum,
       int numReferences, this._absoluteUri)
       : _references = new List<ReferenceableElementForLink>(numReferences),
         _unlinkedUnit = unlinkedUnit;
@@ skipping 56 matching lines @@
       for (UnlinkedExecutable executable in _unlinkedUnit.executables) {
         if (executable.kind == UnlinkedExecutableKind.functionOrMethod) {
           _functions.add(new TopLevelFunctionElementForLink(this, executable));
         }
       }
     }
     return _functions;
   }
 
   @override
+  List<FunctionTypeAliasElementForLink> get functionTypeAliases =>
+      _functionTypeAliases ??= _unlinkedUnit.typedefs
+          .map((UnlinkedTypedef t) =>
+              new FunctionTypeAliasElementForLink(this, t))
+          .toList();
+
+  @override
   String get identifier => _absoluteUri;
 
   /**
    * Indicates whether this compilation element is part of the build unit
    * currently being linked.
    */
   bool get isInBuildUnit;
 
   /**
    * Determine whether type inference is complete in this compilation unit.
@@ skipping 52 matching lines @@
       }
       for (ClassElementForLink_Enum enm in enums) {
         _containedNames[enm.name] = enm;
       }
       for (TopLevelFunctionElementForLink function in functions) {
         _containedNames[function.name] = function;
       }
       for (PropertyAccessorElementForLink accessor in accessors) {
         _containedNames[accessor.name] = accessor;
       }
+      for (FunctionTypeAliasElementForLink functionTypeAlias
+          in functionTypeAliases) {
+        _containedNames[functionTypeAlias.name] = functionTypeAlias;
+      }
       // TODO(paulberry): fill in other top level entities (typedefs
       // and executables).
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   /**
    * Compute the type referred to by the given linked type [slot] (interpreted
    * relative to [typeParameterContext]).  If there is no inferred type in the
@@ skipping 162 matching lines @@
    * If this compilation unit already has a reference in its references table
    * to [element], return its index.  Otherwise add a new reference to the table
    * and return its index.
    */
   int addReference(Element element) {
     if (element is ClassElementForLink) {
       return addRawReference(element.name,
           dependency: library.addDependency(element.library),
           numTypeParameters: element.typeParameters.length,
           unitNum: element.enclosingElement.unitNum);
+    } else if (element is FunctionTypeAliasElementForLink) {
+      return addRawReference(element.name,
+          dependency: library.addDependency(element.library),
+          numTypeParameters: element.typeParameters.length,
+          unitNum: element.enclosingElement.unitNum,
+          kind: ReferenceKind.typedef);
     } else if (element is ExecutableElementForLink) {
       ClassElementForLink_Class enclosingClass = element.enclosingClass;
       ReferenceKind kind;
       switch (element._unlinkedExecutable.kind) {
         case UnlinkedExecutableKind.functionOrMethod:
           kind = enclosingClass != null
               ? ReferenceKind.method
               : ReferenceKind.topLevelFunction;
           break;
         case UnlinkedExecutableKind.setter:
@@ skipping 230 matching lines @@
   }
 
   /**
    * If [constructorElement] redirects to another constructor via a factory
    * redirect, return the constructor it redirects to.
    */
   ConstructorElementForLink _getFactoryRedirectedConstructor() {
     EntityRef redirectedConstructor =
         constructorElement._unlinkedExecutable.redirectedConstructor;
     if (redirectedConstructor != null) {
-      return constructorElement.enclosingUnit
+      return constructorElement.compilationUnit
           ._resolveRef(redirectedConstructor.reference)
           .asConstructor;
     } else {
       return null;
     }
   }
 }
 
 /**
  * Specialization of [DependencyWalker] for detecting constant
@@ skipping 356 matching lines @@
     with TypeParameterizedElementForLink, ParameterParentElementForLink
     implements ExecutableElementImpl {
   /**
    * The unlinked representation of the method in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
-  List<TypeParameterElementForLink> _typeParameters;
   String _name;
   String _displayName;
 
   /**
    * Return the class in which this executable appears, maybe `null` for a
    * top-level function.
    */
   final ClassElementForLink_Class enclosingClass;
 
-  /**
-   * Return the compilation unit in which this executable appears.
-   */
-  final CompilationUnitElementForLink enclosingUnit;
+  @override
+  final CompilationUnitElementForLink compilationUnit;
 
   ExecutableElementForLink(
-      this.enclosingUnit, this.enclosingClass, this._unlinkedExecutable);
+      this.compilationUnit, this.enclosingClass, this._unlinkedExecutable);
 
   /**
    * If the executable element had an explicitly declared return type, return
    * it.  Otherwise return `null`.
    */
   DartType get declaredReturnType {
     if (_unlinkedExecutable.returnType == null) {
       return null;
     } else {
       return _declaredReturnType ??=
-          enclosingUnit._resolveTypeRef(_unlinkedExecutable.returnType, this);
+          compilationUnit._resolveTypeRef(_unlinkedExecutable.returnType, this);
     }
   }
 
   @override
   String get displayName {
     if (_displayName == null) {
       _displayName = _unlinkedExecutable.name;
       if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
         _displayName = _displayName.substring(0, _displayName.length - 1);
       }
     }
     return _displayName;
   }
 
   @override
-  Element get enclosingElement => enclosingClass ?? enclosingUnit;
+  Element get enclosingElement => enclosingClass ?? compilationUnit;
 
   @override
   TypeParameterizedElementForLink get enclosingTypeParameterContext =>
       enclosingClass;
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
   @override
   List<int> get implicitFunctionTypeIndices => const <int>[];
 
   /**
    * Return the inferred return type of the executable element.  Should only be
    * called if no return type was explicitly declared.
    */
   DartType get inferredReturnType {
     // We should only try to infer a return type when none is explicitly
     // declared.
     assert(_unlinkedExecutable.returnType == null);
     if (Linker._initializerTypeInferenceCycle != null &&
         Linker._initializerTypeInferenceCycle ==
-            enclosingUnit.library.libraryCycleForLink) {
+            compilationUnit.library.libraryCycleForLink) {
       // We are currently computing the type of an initializer expression in the
       // current library cycle, so type inference results should be ignored.
       return _computeDefaultReturnType();
     }
     if (_inferredReturnType == null) {
       if (_unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
         // TODO(paulberry): implement.
         throw new UnimplementedError();
-      } else if (enclosingUnit.isInBuildUnit) {
+      } else if (compilationUnit.isInBuildUnit) {
         _inferredReturnType = _computeDefaultReturnType();
       } else {
-        _inferredReturnType = enclosingUnit.getLinkedType(
+        _inferredReturnType = compilationUnit.getLinkedType(
             _unlinkedExecutable.inferredReturnTypeSlot, this);
       }
     }
     return _inferredReturnType;
   }
 
   @override
-  ExecutableElementForLink get innermostExecutable => this;
-
-  @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
   String get name {
@@ skipping 12 matching lines @@
   @override
   void set returnType(DartType inferredType) {
     assert(_inferredReturnType == null);
     _inferredReturnType = inferredType;
   }
 
   @override
   FunctionTypeImpl get type => _type ??= new FunctionTypeImpl(this);
 
   @override
+  TypeParameterizedElementForLink get typeParameterContext => this;
+
+  @override
   List<UnlinkedParam> get unlinkedParameters => _unlinkedExecutable.parameters;
 
   @override
   List<UnlinkedTypeParam> get _unlinkedTypeParams =>
       _unlinkedExecutable.typeParameters;
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
@@ skipping 760 matching lines @@
  * Element representing a function-typed parameter resynthesied from a summary
  * during linking.
  */
 class FunctionElementForLink_FunctionTypedParam extends Object
     with ParameterParentElementForLink
     implements FunctionElement {
   @override
   final ParameterElementForLink enclosingElement;
 
   @override
-  final ExecutableElementForLink innermostExecutable;
+  final TypeParameterizedElementForLink typeParameterContext;
 
   @override
   final List<UnlinkedParam> unlinkedParameters;
 
   DartType _returnType;
   List<int> _implicitFunctionTypeIndices;
 
-  FunctionElementForLink_FunctionTypedParam(
-      this.enclosingElement, this.innermostExecutable, this.unlinkedParameters);
+  FunctionElementForLink_FunctionTypedParam(this.enclosingElement,
+      this.typeParameterContext, this.unlinkedParameters);
 
   @override
   List<int> get implicitFunctionTypeIndices {
     if (_implicitFunctionTypeIndices == null) {
       _implicitFunctionTypeIndices = enclosingElement
           .enclosingElement.implicitFunctionTypeIndices
           .toList();
       _implicitFunctionTypeIndices.add(enclosingElement._parameterIndex);
     }
     return _implicitFunctionTypeIndices;
   }
 
   @override
   DartType get returnType {
     if (_returnType == null) {
       if (enclosingElement._unlinkedParam.type == null) {
         _returnType = DynamicTypeImpl.instance;
       } else {
         _returnType = enclosingElement.compilationUnit._resolveTypeRef(
-            enclosingElement._unlinkedParam.type, innermostExecutable);
+            enclosingElement._unlinkedParam.type, typeParameterContext);
       }
     }
     return _returnType;
   }
 
   @override
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
@@ skipping 29 matching lines @@
   void set returnType(DartType newType) {
     // InstanceMemberInferrer stores the new type both here and on the variable
     // element.  We don't need to record both values, so we ignore it here.
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
+ * Element representing a typedef resynthesized from a summary during linking.
+ */
+class FunctionTypeAliasElementForLink extends Object
+    with TypeParameterizedElementForLink, ParameterParentElementForLink
+    implements
+        FunctionTypeAliasElement,
+        ReferenceableElementForLink,
+        ElementImpl {
+  @override
+  final CompilationUnitElementForLink enclosingElement;
+
+  /**
+   * The unlinked representation of the typedef in the summary.
+   */
+  final UnlinkedTypedef _unlinkedTypedef;
+
+  FunctionTypeImpl _type;
+  DartType _returnType;
+
+  FunctionTypeAliasElementForLink(this.enclosingElement, this._unlinkedTypedef);
+
+  @override
+  ConstructorElementForLink get asConstructor => null;
+
+  @override
+  ConstVariableNode get asConstVariable {
+    // When a typedef name is used as a constant variable, it doesn't depend on
+    // anything, so it is not necessary to include it in the constant
+    // dependency graph.
+    return null;
+  }
+
+  @override
+  DartType get asStaticType {
+    return enclosingElement.enclosingElement._linker.typeProvider.typeType;
+  }
+
+  @override
+  TypeInferenceNode get asTypeInferenceNode => null;
+
+  @override
+  CompilationUnitElementForLink get compilationUnit => enclosingElement;
+
+  @override
+  TypeParameterizedElementForLink get enclosingTypeParameterContext => null;
+
+  @override
+  String get identifier => _unlinkedTypedef.name;
+
+  @override
+  List<int> get implicitFunctionTypeIndices => const <int>[];
+
+  @override
+  bool get isSynthetic => false;
+
+  @override
+  LibraryElementForLink get library => enclosingElement.library;
+
+  @override
+  String get name => _unlinkedTypedef.name;
+
+  @override
+  DartType get returnType => _returnType ??=
+      enclosingElement._resolveTypeRef(_unlinkedTypedef.returnType, this);
+
+  @override
+  TypeParameterizedElementForLink get typeParameterContext => this;
+
+  @override
+  List<UnlinkedParam> get unlinkedParameters => _unlinkedTypedef.parameters;
+
+  @override
+  List<UnlinkedTypeParam> get _unlinkedTypeParams =>
+      _unlinkedTypedef.typeParameters;
+
+  @override
+  DartType buildType(
+      DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
+    int numTypeParameters = _unlinkedTypedef.typeParameters.length;
+    if (numTypeParameters != 0) {
+      List<DartType> typeArguments = new List<DartType>(numTypeParameters);
+      for (int i = 0; i < numTypeParameters; i++) {
+        typeArguments[i] = getTypeArgument(i);
+      }
+      return new FunctionTypeImpl.elementWithNameAndArgs(
+          this, name, typeArguments, true);
+    } else {
+      return _type ??= new FunctionTypeImpl.forTypedef(this);
+    }
+  }
+
+  @override
+  ReferenceableElementForLink getContainedName(String name) {
+    // TODO(paulberry): implement.
+    throw new UnimplementedError();
+  }
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * Specialization of [DependencyWalker] for linking library cycles.
  */
 class LibraryCycleDependencyWalker extends DependencyWalker<LibraryCycleNode> {
   @override
   void evaluate(LibraryCycleNode v) {
     v.link();
   }
 
   @override
   void evaluateScc(List<LibraryCycleNode> scc) {
@@ skipping 665 matching lines @@
  * Element representing a function or method parameter resynthesized
  * from a summary during linking.
  */
 class ParameterElementForLink implements ParameterElementImpl {
   /**
    * The unlinked representation of the parameter in the summary.
    */
   final UnlinkedParam _unlinkedParam;
 
   /**
-   * The innermost executable element containing this parameter.
+   * The innermost enclosing element that can declare type parameters.
    */
-  final ExecutableElementForLink _innermostExecutable;
+  final TypeParameterizedElementForLink _typeParameterContext;
 
   /**
    * If this parameter has a default value and the enclosing library
    * is part of the build unit being linked, the parameter's node in
    * the constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstNode _constNode;
 
   /**
    * The compilation unit in which this parameter appears.
    */
   final CompilationUnitElementForLink compilationUnit;
 
   /**
    * The index of this parameter within [enclosingElement]'s parameter list.
    */
   final int _parameterIndex;
 
   @override
   final ParameterParentElementForLink enclosingElement;
 
   DartType _inferredType;
   DartType _declaredType;
 
   ParameterElementForLink(this.enclosingElement, this._unlinkedParam,
-      this._innermostExecutable, this.compilationUnit, this._parameterIndex) {
+      this._typeParameterContext, this.compilationUnit, this._parameterIndex) {
     if (_unlinkedParam.defaultValue != null) {
       _constNode = new ConstParameterNode(this);
     }
   }
 
   @override
+  String get displayName => _unlinkedParam.name;
+
+  @override
   bool get hasImplicitType =>
       !_unlinkedParam.isFunctionTyped && _unlinkedParam.type == null;
 
   @override
   String get name => _unlinkedParam.name;
 
   @override
   ParameterKind get parameterKind {
     switch (_unlinkedParam.kind) {
       case UnlinkedParamKind.required:
         return ParameterKind.REQUIRED;
       case UnlinkedParamKind.positional:
         return ParameterKind.POSITIONAL;
       case UnlinkedParamKind.named:
         return ParameterKind.NAMED;
     }
   }
 
   @override
   DartType get type {
     if (_inferredType != null) {
       return _inferredType;
     } else if (_declaredType == null) {
       if (_unlinkedParam.isFunctionTyped) {
         _declaredType = new FunctionTypeImpl(
             new FunctionElementForLink_FunctionTypedParam(
-                this, _innermostExecutable, _unlinkedParam.parameters));
+                this, _typeParameterContext, _unlinkedParam.parameters));
       } else if (_unlinkedParam.type == null) {
         if (!compilationUnit.isInBuildUnit) {
           _inferredType = compilationUnit.getLinkedType(
-              _unlinkedParam.inferredTypeSlot, _innermostExecutable);
+              _unlinkedParam.inferredTypeSlot, _typeParameterContext);
           return _inferredType;
         } else {
           _declaredType = DynamicTypeImpl.instance;
         }
       } else {
         _declaredType = compilationUnit._resolveTypeRef(
-            _unlinkedParam.type, _innermostExecutable);
+            _unlinkedParam.type, _typeParameterContext);
       }
     }
     return _declaredType;
   }
 
   @override
   void set type(DartType inferredType) {
     assert(_inferredType == null);
     _inferredType = inferredType;
   }
 
   /**
    * Store the results of type inference for this parameter in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     compilationUnit._storeLinkedType(
-        _unlinkedParam.inferredTypeSlot, _inferredType, _innermostExecutable);
+        _unlinkedParam.inferredTypeSlot, _inferredType, _typeParameterContext);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing the parameter of a synthetic setter for a variable
  * resynthesized during linking.
  */
@@ skipping 28 matching lines @@
   /**
    * Get the appropriate integer list to store in
    * [EntityRef.implicitFunctionTypeIndices] to refer to this element.  For an
    * element representing a function-typed parameter, this should return a
    * non-empty list.  For an element representing an executable, this should
    * return the empty list.
    */
   List<int> get implicitFunctionTypeIndices;
 
   /**
-   * Get the innermost enclosing ExecutableElement (which may be [this], or may
-   * be a parent when there are function-typed parameters).
-   */
-  ExecutableElementForLink get innermostExecutable;
-
-  /**
    * Get all the parameters of this element.
    */
   List<ParameterElementForLink> get parameters {
     if (_parameters == null) {
       List<UnlinkedParam> unlinkedParameters = this.unlinkedParameters;
       int numParameters = unlinkedParameters.length;
       _parameters = new List<ParameterElementForLink>(numParameters);
       for (int i = 0; i < numParameters; i++) {
         UnlinkedParam unlinkedParam = unlinkedParameters[i];
         _parameters[i] = new ParameterElementForLink(this, unlinkedParam,
-            innermostExecutable, innermostExecutable.enclosingUnit, i);
+            typeParameterContext, typeParameterContext.compilationUnit, i);
       }
     }
     return _parameters;
   }
 
   /**
+   * Get the innermost enclosing element that can declare type parameters (which
+   * may be [this], or may be a parent when there are function-typed
+   * parameters).
+   */
+  TypeParameterizedElementForLink get typeParameterContext;
+
+  /**
    * Get the list of unlinked parameters of this element.
    */
   List<UnlinkedParam> get unlinkedParameters;
 }
 
 /**
  * Element representing a getter or setter resynthesized from a summary during
  * linking.
  */
 abstract class PropertyAccessorElementForLink
@@ skipping 536 matching lines @@
 /**
  * Mixin representing an element which can have type parameters.
  */
 abstract class TypeParameterizedElementForLink
     implements TypeParameterizedElement {
   List<TypeParameterType> _typeParameterTypes;
   List<TypeParameterElementForLink> _typeParameters;
   int _nestingLevel;
 
   /**
+   * Get the compilation unit in which this element is declared.
+   */
+  CompilationUnitElementForLink get compilationUnit;
+
+  /**
    * Get the type parameter context enclosing this one, if any.
    */
   TypeParameterizedElementForLink get enclosingTypeParameterContext;
 
   /**
    * Find out how many type parameters are in scope in this context.
    */
   int get typeParameterNestingLevel =>
       _nestingLevel ??= _unlinkedTypeParams.length +
           (enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0);
@@ skipping 372 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }