Add more type inference uses cases to AST-based 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 123 matching lines @@
   if (type is InterfaceType) {
     ClassElementForLink element = type.element;
     int dependency = compilationUnit.library.addDependency(element.library);
     result.reference = compilationUnit.addReference(dependency, element.name,
         element.typeParameters.length, element.enclosingElement.unitNum);
     if (element.typeParameters.isNotEmpty) {
       // TODO(paulberry): implement.
       throw new UnimplementedError();
     }
     return result;
+  } else if (type is VoidTypeImpl) {
+    result.reference = compilationUnit.addReference(0, 'void', 0, 0);
+    return result;
   }
   throw new UnimplementedError('${type.runtimeType}');
 }
 
 /**
  * Type of the callback used by [link] and [relink] to request
  * [LinkedLibrary] objects from other build units.
  */
 typedef LinkedLibrary GetDependencyCallback(String absoluteUri);
 
@@ skipping 86 matching lines @@
    * Throw away any information produced by a previous call to [link].
    */
   void unlink();
 }
 
 /**
  * Element representing a class resynthesized from a summary during
  * linking.
  */
 class ClassElementForLink_Class extends ClassElementForLink
-    implements TypeParameterContext {
+    with TypeParameterizedElementForLink {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   List<ConstructorElementForLink> _constructors;
   ConstructorElementForLink _unnamedConstructor;
   bool _unnamedConstructorComputed = false;
   List<FieldElementForLink_ClassField> _fields;
   InterfaceType _supertype;
   InterfaceType _type;
-  List<TypeParameterElementForLink> _typeParameters;
-  List<TypeParameterType> _typeParameterTypes;
   List<MethodElementForLink> _methods;
   List<InterfaceType> _mixins;
   List<InterfaceType> _interfaces;
+  List<PropertyAccessorElementForLink> _accessors;
 
   ClassElementForLink_Class(
       CompilationUnitElementForLink enclosingElement, this._unlinkedClass)
       : super(enclosingElement);
 
   @override
-  List<PropertyAccessorElement> get accessors {
-    // TODO(paulberry): implement
-    return const [];
+  List<PropertyAccessorElementForLink> get accessors {
+    if (_accessors == null) {
+      _accessors = <PropertyAccessorElementForLink>[];
+      Map<String, SyntheticVariableElementForLink> syntheticVariables =
+          <String, SyntheticVariableElementForLink>{};
+      for (UnlinkedExecutable unlinkedExecutable
+          in _unlinkedClass.executables) {
+        if (unlinkedExecutable.kind == UnlinkedExecutableKind.getter ||
+            unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
+          String name = unlinkedExecutable.name;
+          if (unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
+            assert(name.endsWith('='));
+            name = name.substring(0, name.length - 1);
+          }
+          SyntheticVariableElementForLink syntheticVariable = syntheticVariables
+              .putIfAbsent(name, () => new SyntheticVariableElementForLink());
+          PropertyAccessorElementForLink accessor =
+              new PropertyAccessorElementForLink(
+                  this, unlinkedExecutable, syntheticVariable);
+          _accessors.add(accessor);
+          if (unlinkedExecutable.kind == UnlinkedExecutableKind.getter) {
+            syntheticVariable._getter = accessor;
+          } else {
+            syntheticVariable._setter = accessor;
+          }
+        }
+      }
+    }
+    return _accessors;
   }
 
   @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));
         }
       }
     }
     return _constructors;
   }
 
   @override
   String get displayName => _unlinkedClass.name;
 
   @override
+  TypeParameterContext get enclosingTypeParameterContext => null;
+
+  @override
   List<FieldElementForLink_ClassField> get fields {
     if (_fields == null) {
       _fields = <FieldElementForLink_ClassField>[];
       for (UnlinkedVariable field in _unlinkedClass.fields) {
         _fields.add(new FieldElementForLink_ClassField(this, field));
       }
     }
     return _fields;
   }
 
@@ skipping 31 matching lines @@
 
   @override
   InterfaceType get supertype {
     if (isObject) {
       return null;
     }
     return _supertype ??= _computeInterfaceType(_unlinkedClass.supertype);
   }
 
   @override
-  List<TypeParameterElementForLink> get typeParameters {
-    if (_typeParameters == null) {
-      _typeParameters = _unlinkedClass.typeParameters
-          .map((UnlinkedTypeParam p) => new TypeParameterElementForLink(p))
-          .toList();
-    }
-    return _typeParameters;
-  }
-
-  /**
-   * Get a list of [TypeParameterType] objects corresponding to the
-   * class's type parameters.
-   */
-  List<TypeParameterType> get typeParameterTypes {
-    if (_typeParameterTypes == null) {
-      _typeParameterTypes = typeParameters
-          .map((TypeParameterElementForLink e) => new TypeParameterTypeImpl(e))
-          .toList();
-    }
-    return _typeParameterTypes;
-  }
-
-  @override
   ConstructorElementForLink get unnamedConstructor {
     if (!_unnamedConstructorComputed) {
       for (ConstructorElementForLink constructor in constructors) {
         if (constructor.name.isEmpty) {
           _unnamedConstructor = constructor;
           break;
         }
       }
       _unnamedConstructorComputed = true;
     }
     return _unnamedConstructor;
   }
 
   @override
+  List<UnlinkedTypeParam> get _unlinkedTypeParams =>
+      _unlinkedClass.typeParameters;
+
+  @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     int numTypeParameters = _unlinkedClass.typeParameters.length;
     if (numTypeParameters != 0) {
       return new InterfaceTypeImpl(this);
     } else {
       if (_type == null) {
         List<DartType> typeArguments = new List<DartType>(numTypeParameters);
         for (int i = 0; i < numTypeParameters; i++) {
           typeArguments[i] = getTypeArgument(i);
         }
         _type = new InterfaceTypeImpl.elementWithNameAndArgs(
             this, name, typeArguments);
       }
       return _type;
     }
   }
 
   @override
-  TypeParameterType getTypeParameterType(int index) {
-    List<TypeParameterType> types = typeParameterTypes;
-    return types[types.length - index];
-  }
-
-  @override
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     for (ConstructorElementForLink constructorElement in constructors) {
       constructorElement.link(compilationUnit);
     }
     for (MethodElementForLink methodElement in methods) {
       methodElement.link(compilationUnit);
     }
+    for (PropertyAccessorElementForLink propertyAccessorElement in accessors) {
+      propertyAccessorElement.link(compilationUnit);
+    }
+    for (FieldElementForLink_ClassField fieldElement in fields) {
+      fieldElement.link(compilationUnit);
+    }
   }
 
   @override
   void unlink() {
     hasBeenInferred = false;
     for (MethodElementForLink methodElement in methods) {
       methodElement.unlink();
     }
+    for (PropertyAccessorElementForLink propertyAccessorElement in accessors) {
+      propertyAccessorElement.unlink();
+    }
+    for (FieldElementForLink_ClassField fieldElement in fields) {
+      fieldElement.unlink();
+    }
   }
 
   /**
    * Convert [typeRef] into an [InterfaceType].
    */
   InterfaceType _computeInterfaceType(EntityRef typeRef) {
     if (_unlinkedClass.supertype != null) {
       DartType supertype = enclosingElement._resolveTypeRef(typeRef, this);
       if (supertype is InterfaceType) {
         return supertype;
@@ skipping 818 matching lines @@
         }
       }
     }
 
     // Kick off the algorithm starting with the starting point.
     strongConnect(startingPoint);
   }
 }
 
 /**
+ * Base class for executable elements resynthesized from a summary during
+ * linking.
+ */
+abstract class ExecutableElementForLink extends Object
+    with TypeParameterizedElementForLink
+    implements ExecutableElementImpl, 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;
+
+  /**
+   * TODO(paulberry): this won't always be a class element.
+   */
+  @override
+  final ClassElementForLink_Class enclosingElement;
+
+  ExecutableElementForLink(this.enclosingElement, this._unlinkedExecutable);
+
+  @override
+  TypeParameterContext get enclosingTypeParameterContext => enclosingElement;
+
+  @override
+  bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
+
+  @override
+  bool get isStatic => _unlinkedExecutable.isStatic;
+
+  @override
+  bool get isSynthetic => false;
+
+  @override
+  LibraryElementForLink get library => enclosingElement.library;
+
+  @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, this, enclosingElement.enclosingElement));
+      }
+    }
+    return _parameters;
+  }
+
+  @override
+  DartType get returnType {
+    if (_inferredReturnType != null) {
+      return _inferredReturnType;
+    } else if (_declaredReturnType == null) {
+      if (_unlinkedExecutable.returnType == null) {
+        // In strong mode, setters without an explicit return type are
+        // considered to return `void`.
+        if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter &&
+            library._linker.strongMode) {
+          _declaredReturnType = VoidTypeImpl.instance;
+        } else {
+          _declaredReturnType = DynamicTypeImpl.instance;
+        }
+      } else {
+        _declaredReturnType = enclosingElement.enclosingElement
+            ._resolveTypeRef(_unlinkedExecutable.returnType, this);
+      }
+    }
+    return _declaredReturnType;
+  }
+
+  @override
+  void set returnType(DartType inferredType) {
+    assert(_inferredReturnType == null);
+    _inferredReturnType = inferredType;
+  }
+
+  @override
+  FunctionTypeImpl get type => _type ??= new FunctionTypeImpl(this);
+
+  @override
+  List<TypeParameterElementForLink> get typeParameters {
+    if (_typeParameters == null) {
+      _typeParameters = _unlinkedExecutable.typeParameters
+          .map((UnlinkedTypeParam p) => new TypeParameterElementForLink(p))
+          .toList();
+    }
+    return _typeParameters;
+  }
+
+  @override
+  bool isAccessibleIn(LibraryElement library) =>
+      !Identifier.isPrivateName(name) || identical(this.library, library);
+
+  /**
+   * Store the results of type inference for this method in [compilationUnit].
+   */
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
+    compilationUnit._storeLinkedType(
+        _unlinkedExecutable.inferredReturnTypeSlot, returnType);
+    for (ParameterElementForLink parameterElement in parameters) {
+      parameterElement.link(compilationUnit);
+    }
+  }
+
+  /**
+   * Throw away any information produced by type inference.
+   */
+  void unlink() {
+    for (ParameterElementForLink parameterElement in parameters) {
+      parameterElement.unlink();
+    }
+    _inferredReturnType = null;
+  }
+}
+
+/**
  * Element representing a field resynthesized from a summary during
  * linking.
  */
 abstract class FieldElementForLink
     implements FieldElement, ReferenceableElementForLink {}
 
 /**
  * Specialization of [FieldElementForLink] for class fields.
  */
 class FieldElementForLink_ClassField extends VariableElementForLink
     implements FieldElementForLink {
   @override
   final ClassElementForLink_Class enclosingElement;
 
+  DartType _inferredType;
+  DartType _declaredType;
+
   FieldElementForLink_ClassField(ClassElementForLink_Class enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : enclosingElement = enclosingElement,
         super(unlinkedVariable, enclosingElement.enclosingElement);
 
   @override
   bool get isStatic => unlinkedVariable.isStatic;
+
+  @override
+  DartType get type {
+    if (_inferredType != null) {
+      return _inferredType;
+    } else if (_declaredType == null) {
+      if (unlinkedVariable.type == null) {
+        _declaredType = DynamicTypeImpl.instance;
+      } else {
+        _declaredType = compilationUnit._resolveTypeRef(
+            unlinkedVariable.type, enclosingElement);
+      }
+    }
+    return _declaredType;
+  }
+
+  @override
+  void set type(DartType inferredType) {
+    assert(_inferredType == null);
+    _inferredType = inferredType;
+  }
+
+  /**
+   * Store the results of type inference for this field in
+   * [compilationUnit].
+   */
+  void link(CompilationUnitElementInBuildUnit compilationUnit) {
+    compilationUnit._storeLinkedType(
+        unlinkedVariable.inferredTypeSlot, _inferredType);
+  }
+
+  /**
+   * Throw away any information produced by type inference.
+   */
+  void unlink() {
+    _inferredType = null;
+  }
 }
 
 /**
  * Specialization of [FieldElementForLink] for enum fields.
  */
 class FieldElementForLink_EnumField extends FieldElementForLink
     implements FieldElement {
   /**
    * The unlinked representation of the field in the summary, or `null` if this
    * is an enum's `values` field.
@@ skipping 232 matching lines @@
   @override
   CompilationUnitElementInDependency _makeUnitElement(
           UnlinkedUnit unlinkedUnit, int i) =>
       new CompilationUnitElementInDependency(
           this, unlinkedUnit, _linkedLibrary.units[i], i);
 }
 
 /**
  * Element representing a method resynthesized from a summary during linking.
  */
-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;
+class MethodElementForLink extends ExecutableElementForLink
+    implements MethodElementImpl {
+  MethodElementForLink(ClassElementForLink_Class enclosingElement,
+      UnlinkedExecutable unlinkedExecutable)
+      : super(enclosingElement, unlinkedExecutable);
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
-  LibraryElementForLink get library => enclosingElement.library;
-
-  @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, 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 {
-        _declaredReturnType = enclosingElement.enclosingElement
-            ._resolveTypeRef(_unlinkedExecutable.returnType, this);
-      }
-    }
-    return _declaredReturnType;
-  }
-
-  @override
-  void set returnType(DartType inferredType) {
-    assert(_inferredReturnType == null);
-    _inferredReturnType = inferredType;
-  }
-
-  @override
-  FunctionTypeImpl get type => _type ??= new FunctionTypeImpl(this);
-
-  @override
-  List<TypeParameterElementForLink> get typeParameters {
-    if (_typeParameters == null) {
-      _typeParameters = _unlinkedExecutable.typeParameters
-          .map((UnlinkedTypeParam p) => new TypeParameterElementForLink(p))
-          .toList();
-    }
-    return _typeParameters;
-  }
-
-  @override
-  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 [compilationUnit].
-   */
-  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).
  */
 abstract class Node<NodeType> {
   /**
@@ skipping 148 matching lines @@
 
   /**
    * Throw away any information produced by type inference.
    */
   void unlink() {
     _inferredType = null;
   }
 }
 
 /**
+ * Element representing a getter or setter resynthesized from a summary during
+ * linking.
+ */
+class PropertyAccessorElementForLink extends ExecutableElementForLink
+    implements PropertyAccessorElementImpl {
+  @override
+  SyntheticVariableElementForLink variable;
+
+  PropertyAccessorElementForLink(ClassElementForLink_Class enclosingElement,
+      UnlinkedExecutable unlinkedExecutable, this.variable)
+      : super(enclosingElement, unlinkedExecutable);
+
+  @override
+  PropertyAccessorElementForLink get correspondingGetter => variable.getter;
+
+  @override
+  bool get isGetter =>
+      _unlinkedExecutable.kind == UnlinkedExecutableKind.getter;
+
+  @override
+  bool get isSetter =>
+      _unlinkedExecutable.kind == UnlinkedExecutableKind.setter;
+
+  @override
+  ElementKind get kind => _unlinkedExecutable.kind ==
+      UnlinkedExecutableKind.getter ? ElementKind.GETTER : ElementKind.SETTER;
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * 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
    * other element).  Otherwise return `null`.
    */
   ConstructorElementForLink get asConstructor;
@@ skipping 17 matching lines @@
    * If this element contains other named elements, return the
    * contained element having the given [name].  If this element can't
    * contain other named elements, or it doesn't contain an element
    * with the given name, return the singleton of
    * [UndefinedElementForLink].
    */
   ReferenceableElementForLink getContainedName(String name);
 }
 
 /**
+ * Element representing a synthetic variable resynthesized from a summary during
+ * linking.
+ */
+class SyntheticVariableElementForLink implements PropertyInducingElementImpl {
+  PropertyAccessorElementForLink _getter;
+  PropertyAccessorElementForLink _setter;
+
+  @override
+  PropertyAccessorElementForLink get getter => _getter;
+
+  @override
+  PropertyAccessorElementForLink get setter => _setter;
+
+  @override
+  void set type(DartType inferredType) {}
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
 class TopLevelVariableElementForLink extends VariableElementForLink
     implements TopLevelVariableElement {
   TopLevelVariableElementForLink(CompilationUnitElement enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : super(unlinkedVariable, enclosingElement);
 
   @override
@@ skipping 23 matching lines @@
 
   TypeParameterElementForLink(this._unlinkedTypeParam);
 
   @override
   String get name => _unlinkedTypeParam.name;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
+/**
+ * Mixin representing an element which can have type parameters.
+ */
+abstract class TypeParameterizedElementForLink
+    implements TypeParameterizedElement, TypeParameterContext {
+  List<TypeParameterType> _typeParameterTypes;
+  List<TypeParameterElementForLink> _typeParameters;
+
+  /**
+   * Get the type parameter context enclosing this one, if any.
+   */
+  TypeParameterContext get enclosingTypeParameterContext;
+
+  List<TypeParameterElementForLink> get typeParameters {
+    if (_typeParameters == null) {
+      _typeParameters = _unlinkedTypeParams
+          .map((UnlinkedTypeParam p) => new TypeParameterElementForLink(p))
+          .toList();
+    }
+    return _typeParameters;
+  }
+
+  /**
+   * Get a list of [TypeParameterType] objects corresponding to the
+   * element's type parameters.
+   */
+  List<TypeParameterType> get typeParameterTypes {
+    if (_typeParameterTypes == null) {
+      _typeParameterTypes = typeParameters
+          .map((TypeParameterElementForLink e) => new TypeParameterTypeImpl(e))
+          .toList();
+    }
+    return _typeParameterTypes;
+  }
+
+  /**
+   * Get the [UnlinkedTypeParam]s representing the type parameters declared by
+   * this element.
+   */
+  List<UnlinkedTypeParam> get _unlinkedTypeParams;
+
+  @override
+  TypeParameterType getTypeParameterType(int index) {
+    List<TypeParameterType> types = typeParameterTypes;
+    if (index <= types.length) {
+      return types[types.length - index];
+    } else if (enclosingTypeParameterContext != null) {
+      return enclosingTypeParameterContext
+          .getTypeParameterType(index - types.length);
+    } else {
+      // If we get here, it means that a summary contained a type parameter index
+      // that was out of range.
+      throw new RangeError('Invalid type parameter index');
+    }
+  }
+}
+
 class TypeProviderForLink implements TypeProvider {
   final _Linker _linker;
 
   InterfaceType _boolType;
   InterfaceType _deprecatedType;
   InterfaceType _doubleType;
   InterfaceType _functionType;
   InterfaceType _futureDynamicType;
   InterfaceType _futureNullType;
   InterfaceType _futureType;
@@ skipping 324 matching lines @@
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }