Add support for method parameter type inference to AST summaries.

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 151 matching lines @@
  * during linking.
  */
 abstract class ClassElementForLink
     implements ClassElementImpl, ReferenceableElementForLink {
   Map<String, ReferenceableElementForLink> _containedNames;
 
   @override
   final CompilationUnitElementForLink enclosingElement;
 
   @override
-  bool hasBeenInferred = false;
+  bool hasBeenInferred;
 
-  ClassElementForLink(this.enclosingElement);
+  ClassElementForLink(CompilationUnitElementForLink enclosingElement)
+      : enclosingElement = enclosingElement,
+        hasBeenInferred = !enclosingElement.isInBuildUnit;
 
   @override
   ConstructorElementForLink get asConstructor => unnamedConstructor;
 
   @override
   ConstVariableNode get asConstVariable {
     // When a class 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;
@@ skipping 35 matching lines @@
         }
       }
       // TODO(paulberry): add methods.
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   /**
    * Perform type inference and cycle detection on this class and
-   * store the resulting information in the enclosing elements.
+   * store the resulting information in [compilationUnit].
    */
-  void link(LinkedUnitBuilder linkedUnit);
+  void link(CompilationUnitElementInBuildUnit compilationUnit);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink();
 }
 
@@ skipping 155 matching lines @@
     }
   }
 
   @override
   TypeParameterType getTypeParameterType(int index) {
     List<TypeParameterType> types = typeParameterTypes;
     return types[types.length - index];
   }
 
   @override
-  void link(LinkedUnitBuilder linkedUnit) {
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
     for (ConstructorElementForLink constructorElement in constructors) {
-      constructorElement.link(linkedUnit);
+      constructorElement.link(compilationUnit);
     }
     for (MethodElementForLink methodElement in methods) {
-      methodElement.link(linkedUnit);
+      methodElement.link(compilationUnit);
     }
   }
 
   @override
   void unlink() {
     hasBeenInferred = false;
     for (MethodElementForLink methodElement in methods) {
       methodElement.unlink();
     }
   }
@@ skipping 76 matching lines @@
 
   @override
   ConstructorElementForLink get unnamedConstructor => null;
 
   @override
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       _type ??= new InterfaceTypeImpl(this);
 
   @override
-  void link(LinkedUnitBuilder linkedUnit) {}
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {}
 
   @override
   void unlink() {}
 }
 
 /**
  * Element representing a compilation unit resynthesized from a
  * summary during linking.
  */
 abstract class CompilationUnitElementForLink implements CompilationUnitElement {
@@ skipping 223 matching lines @@
    * Perform type inference and const cycle detection on this
    * compilation unit.
    */
   void link() {
     if (library._linker.strongMode) {
       new InstanceMemberInferrer(enclosingElement._linker.typeProvider,
               enclosingElement.inheritanceManager)
           .inferCompilationUnit(this);
     }
     for (ClassElementForLink classElement in types) {
-      classElement.link(_linkedUnit);
+      classElement.link(this);
     }
   }
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     _linkedUnit.constCycles.clear();
     _linkedUnit.references.length = _unlinkedUnit.references.length;
     _linkedUnit.types.clear();
     for (ClassElementForLink classElement in types) {
       classElement.unlink();
     }
   }
+
+  /**
+   * Store the fact that the given [slot] represents a constant constructor
+   * that is part of a cycle.
+   */
+  void _storeConstCycle(int slot) {
+    _linkedUnit.constCycles.add(slot);
+  }
+
+  /**
+   * Store the given [linkedType] in the given [slot] of the this compilation
+   * unit's linked type list.
+   */
+  void _storeLinkedType(int slot, DartType linkedType) {
+    if (slot != 0) {
+      if (linkedType != null && !linkedType.isDynamic) {
+        _linkedUnit.types.add(_createLinkedType(linkedType, this, slot: slot));
+      }
+    }
+  }
 }
 
 /**
  * Element representing a compilation unit which is depended upon
  * (either directly or indirectly) by the build unit being linked.
+ *
+ * TODO(paulberry): ensure that inferred types in dependencies are properly
+ * resynthesized.
  */
 class CompilationUnitElementInDependency extends CompilationUnitElementForLink {
   @override
   final LinkedUnit _linkedUnit;
 
   @override
   final LibraryElementInDependency enclosingElement;
 
   CompilationUnitElementInDependency(this.enclosingElement,
       UnlinkedUnit unlinkedUnit, this._linkedUnit, int unitNum)
@@ skipping 264 matching lines @@
   }
 
   @override
   String get name => _unlinkedExecutable.name;
 
   @override
   List<ParameterElementForLink> get parameters {
     if (_parameters == null) {
       _parameters = <ParameterElementForLink>[];
       for (UnlinkedParam unlinkedParam in _unlinkedExecutable.parameters) {
-        _parameters.add(new ParameterElementForLink(
-            unlinkedParam, enclosingElement.enclosingElement));
+        _parameters.add(new ParameterElementForLink(unlinkedParam,
+            enclosingElement, enclosingElement.enclosingElement));
       }
     }
     return _parameters;
   }
 
   @override
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) =>
       UndefinedElementForLink.instance;
 
   /**
    * Perform const cycle detection on this constructor.
    */
-  void link(LinkedUnitBuilder linkedUnit) {
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (_constNode != null && !isCycleFree) {
-      linkedUnit.constCycles.add(_unlinkedExecutable.constCycleSlot);
+      compilationUnit._storeConstCycle(_unlinkedExecutable.constCycleSlot);
     }
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Instance of [ConstNode] representing a constant field or constant
  * top level variable.
@@ skipping 377 matching lines @@
     }
   }
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     _linkedLibrary.dependencies.length =
         _linkedLibrary.numPrelinkedDependencies;
     for (CompilationUnitElementInBuildUnit unit in units) {
-      unit.link();
+      unit.unlink();
     }
   }
 
   @override
   CompilationUnitElementInBuildUnit _makeUnitElement(
           UnlinkedUnit unlinkedUnit, int i) =>
       new CompilationUnitElementInBuildUnit(
           this, unlinkedUnit, _linkedLibrary.units[i], i);
 }
 
@@ skipping 23 matching lines @@
 class MethodElementForLink implements MethodElementImpl, TypeParameterContext {
   /**
    * The unlinked representation of the method in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   List<TypeParameterElementForLink> _typeParameters;
+  List<ParameterElementForLink> _parameters;
 
   @override
   final ClassElementForLink_Class enclosingElement;
 
   MethodElementForLink(this.enclosingElement, this._unlinkedExecutable);
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
   @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
   String get name => _unlinkedExecutable.name;
 
   @override
   List<ParameterElementForLink> get parameters {
-    // TODO(paulberry): implement.
-    return const [];
+    if (_parameters == null) {
+      _parameters = <ParameterElementForLink>[];
+      for (UnlinkedParam unlinkedParam in _unlinkedExecutable.parameters) {
+        _parameters.add(new ParameterElementForLink(
+            unlinkedParam, this, enclosingElement.enclosingElement));
+      }
+    }
+    return _parameters;
   }
 
   @override
   DartType get returnType {
     if (_inferredReturnType != null) {
       return _inferredReturnType;
     } else if (_declaredReturnType == null) {
       if (_unlinkedExecutable.returnType == null) {
         _declaredReturnType = DynamicTypeImpl.instance;
       } else {
@@ skipping 27 matching lines @@
   TypeParameterType getTypeParameterType(int index) {
     // TODO(paulberry): implement.
     throw new UnimplementedError();
   }
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   /**
-   * Store the results of type inference for this method in [linkedUnit].
+   * Store the results of type inference for this method in [compilationUnit].
    */
-  void link(LinkedUnitBuilder linkedUnit) {
-    int slot = _unlinkedExecutable.inferredReturnTypeSlot;
-    if (slot != 0) {
-      DartType inferredReturnType = returnType;
-      if (!inferredReturnType.isDynamic) {
-        linkedUnit.types.add(_createLinkedType(
-            inferredReturnType, enclosingElement.enclosingElement,
-            slot: slot));
-      }
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
+    compilationUnit._storeLinkedType(
+        _unlinkedExecutable.inferredReturnTypeSlot, _inferredReturnType);
+    for (ParameterElementForLink parameterElement in parameters) {
+      parameterElement.link(compilationUnit);
     }
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   /**
    * Throw away any information produced by type inference.
    */
   void unlink() {
+    for (ParameterElementForLink parameterElement in parameters) {
+      parameterElement.unlink();
+    }
     _inferredReturnType = null;
   }
 }
 
 /**
  * Instances of [Node] represent nodes in a dependency graph.  The
  * type parameter, [NodeType], is the derived type (this affords some
  * extra type safety by making it difficult to accidentally construct
  * bridges between unrelated dependency graphs).
  */
@@ skipping 56 matching lines @@
       DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) => this;
 }
 
 /**
  * Element representing a function or method parameter resynthesized
  * from a summary during linking.
  */
-class ParameterElementForLink implements ParameterElement {
+class ParameterElementForLink implements ParameterElementImpl {
   /**
    * The unlinked representation of the parameter in the summary.
    */
   final UnlinkedParam _unlinkedParam;
 
   /**
+   * The context in which type parameters should be interpreted.
+   */
+  final TypeParameterContext _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;
 
-  ParameterElementForLink(this._unlinkedParam, this.compilationUnit) {
+  DartType _inferredType;
+  DartType _declaredType;
+
+  ParameterElementForLink(
+      this._unlinkedParam, this._typeParameterContext, this.compilationUnit) {
     if (_unlinkedParam.defaultValue != null) {
       _constNode = new ConstParameterNode(this);
     }
   }
 
   @override
+  bool get hasImplicitType =>
+      !_unlinkedParam.isFunctionTyped && _unlinkedParam.type == null;
+
+  @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) {
+        // TODO(paulberry): implement.
+        throw new UnimplementedError();
+      } else if (_unlinkedParam.type == null) {
+        _declaredType = DynamicTypeImpl.instance;
+      } else {
+        _declaredType = compilationUnit._resolveTypeRef(
+            _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);
+  }
+
+  @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  /**
+   * Throw away any information produced by type inference.
+   */
+  void unlink() {
+    _inferredType = null;
+  }
 }
 
 /**
  * Abstract base class representing an element which can be the target
  * of a reference.
  */
 abstract class ReferenceableElementForLink {
   /**
    * If this element can be used in a constructor invocation context,
    * return the associated constructor (which may be `this` or some
@@ skipping 269 matching lines @@
     }
   }
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
   ConstVariableNode get asConstVariable => _constNode;
 
   @override
-  bool get hasImplicitType => unlinkedVariable.type != null;
+  bool get hasImplicitType => unlinkedVariable.type == null;
 
   @override
   FunctionElementForLink_Initializer get initializer =>
       _initializer ??= new FunctionElementForLink_Initializer();
 
   @override
   bool get isConst => unlinkedVariable.isConst;
 
   @override
   bool get isFinal => unlinkedVariable.isFinal;
@@ skipping 117 matching lines @@
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }