Support for type inference of top-level function invocations.

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 182 matching lines @@
           compilationUnit.addReference(element.enclosingExecutable);
       result.implicitFunctionTypeIndices = element.implicitFunctionTypeIndices;
       if (type.typeArguments.isNotEmpty) {
         result.typeArguments = type.typeArguments
             .map((DartType t) =>
                 _createLinkedType(t, compilationUnit, typeParameterContext))
             .toList();
       }
       return result;
     }
+    if (element is TopLevelFunctionElementForLink) {
+      result.reference = compilationUnit.addReference(element);
+      if (type.typeArguments.isNotEmpty) {
+        result.typeArguments = type.typeArguments
+            .map((DartType t) =>
+                _createLinkedType(t, compilationUnit, typeParameterContext))
+            .toList();
+      }
+      return result;
+    }
     if (element is MethodElementForLink) {
       result.reference = compilationUnit.addReference(element);
       if (type.typeArguments.isNotEmpty) {
         result.typeArguments = type.typeArguments
             .map((DartType t) =>
                 _createLinkedType(t, compilationUnit, typeParameterContext))
             .toList();
       }
       return result;
     }
@@ skipping 446 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;
 
   /**
    * 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;
 
   @override
   LibraryElementForLink get enclosingElement;
 
   @override
   List<ClassElementForLink_Enum> get enums {
     if (_enums == null) {
       _enums = <ClassElementForLink_Enum>[];
       for (UnlinkedEnum unlinkedEnum in _unlinkedUnit.enums) {
         _enums.add(new ClassElementForLink_Enum(this, unlinkedEnum));
       }
     }
     return _enums;
   }
 
   @override
+  List<TopLevelFunctionElementForLink> get functions {
+    if (_functions == null) {
+      _functions = <TopLevelFunctionElementForLink>[];
+      for (UnlinkedExecutable executable in _unlinkedUnit.executables) {

[Paul Berry, 2016/04/18 20:08:27]

Is CompilationUnitElement.functions supposed to return all executables
(functions, getters, and setters), or just functions?  I thought it was just
functions.

Assuming I'm remembering right, we'll need an "if" test here to make sure we
only add top level functions to the list.

[scheglov, 2016/04/18 20:24:34]

You're right.
Done.

+        _functions.add(new TopLevelFunctionElementForLink(this, executable));
+      }
+    }
+    return _functions;
+  }
+
+  @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 49 matching lines @@
       // TODO(paulberry): what's the correct way to handle name conflicts?
       for (ClassElementForLink_Class type in types) {
         _containedNames[type.name] = type;
       }
       for (ClassElementForLink_Enum enm in enums) {
         _containedNames[enm.name] = enm;
       }
       for (TopLevelVariableElementForLink variable in topLevelVariables) {
         _containedNames[variable.name] = variable;
       }
+      for (TopLevelFunctionElementForLink function in functions) {
+        _containedNames[function.name] = function;
+      }
       // 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 163 matching lines @@
    * 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 ExecutableElementForLink) {
-      // TODO(paulberry): will this code ever be executed for an executable
-      // element that's not inside a class?
-      assert(element.enclosingElement is ClassElementForLink_Class);
+      ClassElementForLink_Class enclosingClass = element.enclosingClass;
       ReferenceKind kind;
       switch (element._unlinkedExecutable.kind) {
         case UnlinkedExecutableKind.functionOrMethod:
-          kind = ReferenceKind.method;
+          kind = enclosingClass != null
+              ? ReferenceKind.method
+              : ReferenceKind.topLevelFunction;
           break;
         case UnlinkedExecutableKind.setter:
           kind = ReferenceKind.propertyAccessor;
           break;
         default:
           // TODO(paulberry): implement other cases as necessary
           throw new UnimplementedError('${element._unlinkedExecutable.kind}');
       }
       return addRawReference(element.name,
           numTypeParameters: element.typeParameters.length,
-          containingReference: addReference(element.enclosingElement),
+          containingReference:
+              enclosingClass != null ? addReference(enclosingClass) : null,
           kind: kind);
     }
     // TODO(paulberry): implement other cases
     throw new UnimplementedError('${element.runtimeType}');
   }
 
   @override
   DartType getLinkedType(
       int slot, TypeParameterizedElementForLink typeParameterContext) {
     // This method should only be called on compilation units that come from
@@ skipping 164 matching lines @@
           if (superClass != null && !superClass.isObject) {
             ConstructorElementForLink constructor = superClass
                 .getContainedName(constructorInitializer.name)
                 .asConstructor;
             safeAddDependency(constructor?._constNode);
           }
         } else if (constructorInitializer.kind ==
             UnlinkedConstructorInitializerKind.thisInvocation) {
           defaultSuperInvocationNeeded = false;
           ConstructorElementForLink constructor = constructorElement
-              .enclosingElement
+              .enclosingClass
               .getContainedName(constructorInitializer.name)
               .asConstructor;
           safeAddDependency(constructor?._constNode);
         }
         CompilationUnitElementForLink compilationUnit =
             constructorElement.enclosingElement.enclosingElement;
         collectDependencies(
             dependencies, constructorInitializer.expression, compilationUnit);
         for (UnlinkedConst unlinkedConst in constructorInitializer.arguments) {
           collectDependencies(dependencies, unlinkedConst, compilationUnit);
@@ skipping 25 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.enclosingElement.enclosingElement
+      return constructorElement.enclosingUnit
           ._resolveRef(redirectedConstructor.reference)
           .asConstructor;
     } else {
       return null;
     }
   }
 }
 
 /**
  * Specialization of [DependencyWalker] for detecting constant
@@ skipping 101 matching lines @@
  */
 class ConstructorElementForLink extends ExecutableElementForLink
     implements ConstructorElementImpl, ReferenceableElementForLink {
   /**
    * If this is a `const` constructor and the enclosing library is
    * part of the build unit being linked, the constructor's node in
    * the constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstConstructorNode _constNode;
 
-  ConstructorElementForLink(ClassElementForLink_Class enclosingElement,
+  ConstructorElementForLink(ClassElementForLink_Class enclosingClass,
       UnlinkedExecutable unlinkedExecutable)
-      : super(enclosingElement, unlinkedExecutable) {
-    if (enclosingElement.enclosingElement.isInBuildUnit &&
+      : super(enclosingClass.enclosingElement, enclosingClass,
+            unlinkedExecutable) {
+    if (enclosingClass.enclosingElement.isInBuildUnit &&
         _unlinkedExecutable != null &&
         _unlinkedExecutable.constCycleSlot != 0) {
       _constNode = new ConstConstructorNode(this);
     }
   }
 
   @override
   ConstructorElementForLink get asConstructor => this;
 
   @override
@@ skipping 235 matching lines @@
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   List<TypeParameterElementForLink> _typeParameters;
   String _name;
   List<ParameterElementForLink> _parameters;
   String _displayName;
 
   /**
-   * TODO(paulberry): this won't always be a class element.
+   * Return the class in which this executable appears, maybe `null` for a
+   * top-level function.
    */
-  @override
-  final ClassElementForLink_Class enclosingElement;
-
-  ExecutableElementForLink(this.enclosingElement, this._unlinkedExecutable);
+  final ClassElementForLink_Class enclosingClass;
 
   /**
    * Return the compilation unit in which this executable appears.
    */
-  CompilationUnitElementForLink get compilationUnit =>
-      enclosingElement.enclosingElement;
+  final CompilationUnitElementForLink enclosingUnit;
+
+  ExecutableElementForLink(
+      this.enclosingUnit, this.enclosingClass, this._unlinkedExecutable);
 
   @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;
+
+  @override
   TypeParameterizedElementForLink get enclosingTypeParameterContext =>
-      enclosingElement;
+      enclosingClass;
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
   @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
 
@@ skipping 12 matching lines @@
   }
 
   @override
   List<ParameterElementForLink> get parameters {
     if (_parameters == null) {
       int numParameters = _unlinkedExecutable.parameters.length;
       _parameters = new List<ParameterElementForLink>(numParameters);
       for (int i = 0; i < numParameters; i++) {
         UnlinkedParam unlinkedParam = _unlinkedExecutable.parameters[i];
         _parameters[i] = new ParameterElementForLink(
-            this, unlinkedParam, this, enclosingElement.enclosingElement, i);
+            this, unlinkedParam, this, enclosingUnit, i);
       }
     }
     return _parameters;
   }
 
   @override
   DartType get returnType {
     if (_inferredReturnType != null) {
       return _inferredReturnType;
     } else if (_declaredReturnType == null) {
       if (_unlinkedExecutable.returnType == null) {
         if (_unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
           // TODO(paulberry): implement.
           throw new UnimplementedError();
-        } else if (!compilationUnit.isInBuildUnit) {
-          _inferredReturnType = compilationUnit.getLinkedType(
+        } else if (!enclosingUnit.isInBuildUnit) {
+          _inferredReturnType = enclosingUnit.getLinkedType(
               _unlinkedExecutable.inferredReturnTypeSlot, this);
           return _inferredReturnType;
         } else if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter &&
             library._linker.strongMode) {
           // In strong mode, setters without an explicit return type are
           // considered to return `void`.
           _declaredReturnType = VoidTypeImpl.instance;
         } else {
           _declaredReturnType = DynamicTypeImpl.instance;
         }
       } else {
-        _declaredReturnType = enclosingElement.enclosingElement
-            ._resolveTypeRef(_unlinkedExecutable.returnType, this);
+        _declaredReturnType =
+            enclosingUnit._resolveTypeRef(_unlinkedExecutable.returnType, this);
       }
     }
     return _declaredReturnType;
   }
 
   @override
   void set returnType(DartType inferredType) {
     assert(_inferredReturnType == null);
     _inferredReturnType = inferredType;
   }
@@ skipping 339 matching lines @@
     }());
   }
 
   void _doInvokeConstructor() {
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     // TODO(paulberry): don't just pop the args; use their types
     // to infer the type of type arguments.
     stack.length -= numNamed + numPositional;
     strPtr += numNamed;
-    EntityRef ref = unlinkedConst.references[refPtr++];
+    EntityRef ref = _getNextRef();
     ConstructorElementForLink element =
         unit._resolveRef(ref.reference).asConstructor;
     if (element != null) {
-      stack.add(element.enclosingElement.buildType(
+      stack.add(element.enclosingClass.buildType(
           (int i) => i >= ref.typeArguments.length
               ? DynamicTypeImpl.instance
               : unit._resolveTypeRef(
                   ref.typeArguments[i], variable._typeParameterContext),
           const []));
     } else {
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
@@ skipping 20 matching lines @@
       return DynamicTypeImpl.instance;
     }());
   }
 
   void _doInvokeMethodRef() {
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     List<String> namedArgNames = _getNextStrings(numNamed);
     List<DartType> namedArgTypeList = _popList(numNamed);
     List<DartType> positionalArgTypes = _popList(numPositional);
-    EntityRef ref = unlinkedConst.references[refPtr++];
+    EntityRef ref = _getNextRef();
     ReferenceableElementForLink element = unit._resolveRef(ref.reference);
     stack.add(() {
       DartType rawType = element.asStaticType;
       if (rawType is FunctionType) {
         FunctionType inferredType = _inferExecutableType(rawType, numNamed,
             numPositional, namedArgNames, namedArgTypeList, positionalArgTypes);
         if (inferredType != null) {
           return inferredType.returnType;
         }
       }
@@ skipping 36 matching lines @@
         valueType =
             valueType == null ? type : _leastUpperBound(valueType, type);
       }
     }
     keyType = _dynamicIfNull(keyType);
     valueType = _dynamicIfNull(valueType);
     stack.add(typeProvider.mapType.instantiate(<DartType>[keyType, valueType]));
   }
 
   void _doPushReference() {
-    EntityRef ref = unlinkedConst.references[refPtr++];
+    EntityRef ref = _getNextRef();
     if (ref.paramReference != 0) {
       stack.add(typeProvider.typeType);
     } else {
       // Synthetic function types can't be directly referred
       // to by expressions.
       assert(ref.syntheticReturnType == null);
       // Nor can implicit function types derived from
       // function-typed parameters.
       assert(ref.implicitFunctionTypeIndices.isEmpty);
-      ReferenceableElementForLink element =
-          variable.compilationUnit._resolveRef(ref.reference);
+      ReferenceableElementForLink element = unit._resolveRef(ref.reference);
       stack.add(element.asStaticType);
     }
   }
 
   int _getNextInt() {
     return unlinkedConst.ints[intPtr++];
   }
 
+  EntityRef _getNextRef() => unlinkedConst.references[refPtr++];
+
   String _getNextString() {
     return unlinkedConst.strings[strPtr++];
   }
 
   List<String> _getNextStrings(int n) {
     List<String> result = new List<String>(n);
     for (int i = 0; i < n; i++) {
       result[i] = _getNextString();
     }
     return result;
   }
 
   DartType _getNextTypeRef() {
-    EntityRef ref = unlinkedConst.references[refPtr++];
+    EntityRef ref = _getNextRef();
     return unit._resolveTypeRef(ref, variable._typeParameterContext);
   }
 
   /**
    * Return the type of the property with the given [propertyName] in the
    * given [targetType]. May return `dynamic` if the property cannot be
    * resolved.
    */
   DartType _getPropertyType(DartType targetType, String propertyName) {
     return targetType is InterfaceType
@@ skipping 914 matching lines @@
       library.unlink();
     }
   }
 }
 
 /**
  * Element representing a method resynthesized from a summary during linking.
  */
 class MethodElementForLink extends ExecutableElementForLink
     implements MethodElementImpl {
-  MethodElementForLink(ClassElementForLink_Class enclosingElement,
+  MethodElementForLink(ClassElementForLink_Class enclosingClass,
       UnlinkedExecutable unlinkedExecutable)
-      : super(enclosingElement, unlinkedExecutable);
+      : super(enclosingClass.enclosingElement, enclosingClass,
+            unlinkedExecutable);
 
   @override
   String get identifier => name;
 
   @override
   ElementKind get kind => ElementKind.METHOD;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
@@ skipping 251 matching lines @@
 /**
  * Specialization of [PropertyAccessorElementForLink] for non-synthetic
  * accessors explicitly declared in the source code.
  */
 class PropertyAccessorElementForLink_Executable extends ExecutableElementForLink
     implements PropertyAccessorElementForLink {
   @override
   SyntheticVariableElementForLink variable;
 
   PropertyAccessorElementForLink_Executable(
-      ClassElementForLink_Class enclosingElement,
+      ClassElementForLink_Class enclosingClass,
       UnlinkedExecutable unlinkedExecutable,
       this.variable)
-      : super(enclosingElement, unlinkedExecutable);
+      : super(enclosingClass.enclosingElement, enclosingClass,
+            unlinkedExecutable);
 
   @override
   PropertyAccessorElementForLink_Executable get correspondingGetter =>
       variable.getter;
 
   @override
   bool get isGetter =>
       _unlinkedExecutable.kind == UnlinkedExecutableKind.getter;
 
   @override
@@ skipping 210 matching lines @@
   PropertyAccessorElementForLink_Executable get setter => _setter;
 
   @override
   void set type(DartType inferredType) {}
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
+ * Element representing a top-level function.
+ */
+class TopLevelFunctionElementForLink extends ExecutableElementForLink
+    implements FunctionElementImpl, ReferenceableElementForLink {
+  DartType _returnType;
+
+  TopLevelFunctionElementForLink(
+      CompilationUnitElementForLink enclosingUnit, UnlinkedExecutable _buf)
+      : super(enclosingUnit, null, _buf);
+
+  @override
+  ConstVariableNode get asConstVariable => null;
+
+  @override
+  DartType get asStaticType => type;
+
+  @override
+  TypeInferenceNode get asTypeInferenceNode => null;
+
+  @override
+  ElementKind get kind => ElementKind.FUNCTION;
+
+  @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 589 matching lines @@
       if (type is InterfaceType) {
         Element result = type.lookUpGetter(name, compilationUnit.library);
         result ??= type.lookUpMethod(name, compilationUnit.library);
         return result;
       }
     }
     // TODO(scheglov): implement for propagated types
     return null;
   }
 }