Remove toplevel inference restriction hints, and restore as much

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 1338 matching lines @@
         'Linker tried to access linked type from current build unit');
   }
 
   /**
    * Perform type inference and const cycle detection on this
    * compilation unit.
    */
   void link() {
     if (library._linker.strongMode) {
       new InstanceMemberInferrer(
-              enclosingElement._linker.typeProvider,
-              (clazz) => (clazz.library as LibraryElementInBuildUnit)
-                  .inheritanceManager,
-              new Set<FieldElement>())
-          .inferCompilationUnit(this);
+          enclosingElement._linker.typeProvider,
+          (clazz) => (clazz.library as LibraryElementInBuildUnit)
+              .inheritanceManager).inferCompilationUnit(this);
       for (TopLevelVariableElementForLink variable in topLevelVariables) {
         variable.link(this);
       }
     }
     for (ClassElementForLink classElement in types) {
       classElement.link(this);
     }
   }
 
   /**
@@ skipping 749 matching lines @@
         case UnlinkedExprOperation.pushNull:
           stack.add(typeProvider.nullType);
           break;
         case UnlinkedExprOperation.pushSuper:
           stack.add(DynamicTypeImpl.instance);
           break;
         case UnlinkedExprOperation.pushThis:
           stack.add(DynamicTypeImpl.instance);
           break;
         case UnlinkedExprOperation.pushReference:
-          try {
-            _doPushReference();
-          } on _InferenceFailedError {
-            errorKind = TopLevelInferenceErrorKind.instanceGetter;
-            return DynamicTypeImpl.instance;
-          }
+          _doPushReference();
           break;
         case UnlinkedExprOperation.extractProperty:
-          try {
-            _doExtractProperty();
-          } on _InferenceFailedError {
-            errorKind = TopLevelInferenceErrorKind.instanceGetter;
-            return DynamicTypeImpl.instance;
-          }
+          _doExtractProperty();
           break;
         case UnlinkedExprOperation.invokeConstructor:
           _doInvokeConstructor();
           break;
         case UnlinkedExprOperation.makeUntypedList:
           _doMakeUntypedList();
           break;
         case UnlinkedExprOperation.makeUntypedMap:
           _doMakeUntypedMap();
           break;
@@ skipping 62 matching lines @@
         case UnlinkedExprOperation.lessEqual:
           _computeBinaryExpressionType(TokenType.LT_EQ);
           break;
         case UnlinkedExprOperation.modulo:
           _computeBinaryExpressionType(TokenType.PERCENT);
           break;
         case UnlinkedExprOperation.conditional:
           _doConditional();
           break;
         case UnlinkedExprOperation.assignToIndex:
+          _doAssignToIndex();
+          break;
         case UnlinkedExprOperation.assignToProperty:
+          _doAssignToProperty();
+          break;
         case UnlinkedExprOperation.assignToRef:
-          errorKind = TopLevelInferenceErrorKind.assignment;
-          return DynamicTypeImpl.instance;
+          _doAssignToRef();
+          break;
         case UnlinkedExprOperation.await:
           _doAwait();
           break;
         case UnlinkedExprOperation.extractIndex:
           _doExtractIndex();
           break;
         case UnlinkedExprOperation.invokeMethodRef:
-          try {
-            _doInvokeMethodRef();
-          } on _InferenceFailedError {
-            errorKind = TopLevelInferenceErrorKind.instanceGetter;
-            return DynamicTypeImpl.instance;
-          }
+          _doInvokeMethodRef();
           break;
         case UnlinkedExprOperation.invokeMethod:
           _doInvokeMethod();
           break;
         case UnlinkedExprOperation.cascadeSectionBegin:
           stack.add(stack.last);
           break;
         case UnlinkedExprOperation.cascadeSectionEnd:
           stack.removeLast();
           break;
@@ skipping 48 matching lines @@
           operand.lookUpInheritedMethod(operatorName, library: library);
       if (method != null) {
         DartType type = method.returnType;
         stack.add(type);
         return;
       }
     }
     stack.add(DynamicTypeImpl.instance);
   }
 
+  void _doAssignment() {
+    UnlinkedExprAssignOperator operator =
+        unlinkedConst.assignmentOperators[assignmentOperatorPtr++];
+    if (isIncrementOrDecrement(operator)) {
+      _doIncrementOrDecrement(operator);
+      return;
+    }
+    if (operator == UnlinkedExprAssignOperator.assign) {
+      stack.removeLast();
+      return; // type is on the stack
+    }
+    TokenType binaryOperator = _convertAssignOperatorToTokenType(operator);
+    _computeBinaryExpressionType(binaryOperator);
+  }
+
+  void _doAssignToIndex() {
+    _doExtractIndex();
+    _doAssignment();
+  }
+
+  void _doAssignToProperty() {
+    _doExtractProperty();
+    _doAssignment();
+  }
+
+  void _doAssignToRef() {
+    EntityRef ref = _getNextRef();
+    ReferenceableElementForLink element = unit.resolveRef(ref.reference);
+    stack.add(element.asStaticType);
+    _doAssignment();
+  }
+
   void _doAwait() {
     DartType type = stack.removeLast();
     DartType typeArgument = type?.flattenFutures(linker.typeSystem);
     typeArgument = _dynamicIfNull(typeArgument);
     stack.add(typeArgument);
   }
 
   void _doConditional() {
     DartType elseType = stack.removeLast();
     DartType thenType = stack.removeLast();
@@ skipping 22 matching lines @@
     DartType target = stack.removeLast();
     if (target.isDynamic) {
       target = typeProvider.objectType;
     }
     String propertyName = _getNextString();
     stack.add(() {
       if (target is InterfaceType) {
         ExecutableElement element = target
             .lookUpInheritedGetterOrMethod(propertyName, library: library);
         if (element != null) {
-          _throwIfInstanceFieldOrAccessor(element);
           if (element is PropertyAccessorElement) {
             return element.returnType;
           } else {
             // Method tear-off
             return element.type;
           }
         }
       }
       return DynamicTypeImpl.instance;
     }());
   }
 
   void _doIfNull() {
     DartType secondType = stack.removeLast();
     DartType firstType = stack.removeLast();
     DartType type = _leastUpperBound(firstType, secondType);
     type = _dynamicIfNull(type);
     stack.add(type);
   }
 
+  void _doIncrementOrDecrement(UnlinkedExprAssignOperator operator) {
+    switch (operator) {
+      case UnlinkedExprAssignOperator.prefixDecrement:
+        stack.add(typeProvider.intType);
+        _computeBinaryExpressionType(TokenType.MINUS);
+        return;
+      case UnlinkedExprAssignOperator.prefixIncrement:
+        stack.add(typeProvider.intType);
+        _computeBinaryExpressionType(TokenType.PLUS);
+        return;
+      case UnlinkedExprAssignOperator.postfixDecrement:
+      case UnlinkedExprAssignOperator.postfixIncrement:
+        return; // Return the operand type
+      default:
+        stack.removeLast();
+        stack.add(DynamicTypeImpl.instance);
+        return;
+    }
+  }
+
   void _doInvokeConstructor() {
     int numNamed = unlinkedConst.ints[intPtr++];
     int numPositional = unlinkedConst.ints[intPtr++];
     List<String> namedArgNames = _getNextStrings(numNamed);
     List<DartType> namedArgTypeList = _popList(numNamed);
     List<DartType> positionalArgTypes = _popList(numPositional);
 
     EntityRef ref = _getNextRef();
     ReferenceableElementForLink refElement = unit.resolveRef(ref.reference);
     ConstructorElementForLink constructorElement = refElement.asConstructor;
@@ skipping 74 matching lines @@
   }
 
   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 = _getNextRef();
     ReferenceableElementForLink element = unit.resolveRef(ref.reference);
-    _throwIfInstanceFieldOrAccessor(element);
     List<DartType> typeArguments = _getTypeArguments();
     stack.add(() {
       DartType rawType = element.asStaticType;
       if (rawType is FunctionType) {
         FunctionType inferredType = _inferExecutableType(
             rawType,
             numNamed,
             numPositional,
             namedArgNames,
             namedArgTypeList,
@@ skipping 53 matching lines @@
     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 = unit.resolveRef(ref.reference);
-      _throwIfInstanceFieldOrAccessor(element);
       stack.add(element.asStaticType);
     }
   }
 
   /**
    * Find the parameter in scope called [parameterName] and return its type.
    */
   DartType _findParameterType(String parameterName) {
     FunctionElementForLink_Local f = this.function;
     while (true) {
@@ skipping 130 matching lines @@
         DartType type = method.returnType;
         type = linker.typeSystem
             .refineBinaryExpressionType(left, operator, right, type);
         stack.add(type);
         return;
       }
     }
     stack.add(DynamicTypeImpl.instance);
   }
 
-  void _throwIfInstanceFieldOrAccessor(Object element) {
-    if (element is NonstaticMemberElementForLink &&
-            element.hasInstanceGetterReference ||
-        element is FieldElement && !element.isStatic ||
-        element is PropertyAccessorElement && !element.isStatic) {
-      throw new _InferenceFailedError(
-          'Instance fields cannot be used for type inference.');
+  static TokenType _convertAssignOperatorToTokenType(
+      UnlinkedExprAssignOperator o) {
+    switch (o) {
+      case UnlinkedExprAssignOperator.assign:
+        return null;
+      case UnlinkedExprAssignOperator.ifNull:
+        return TokenType.QUESTION_QUESTION;
+      case UnlinkedExprAssignOperator.multiply:
+        return TokenType.STAR;
+      case UnlinkedExprAssignOperator.divide:
+        return TokenType.SLASH;
+      case UnlinkedExprAssignOperator.floorDivide:
+        return TokenType.TILDE_SLASH;
+      case UnlinkedExprAssignOperator.modulo:
+        return TokenType.PERCENT;
+      case UnlinkedExprAssignOperator.plus:
+        return TokenType.PLUS;
+      case UnlinkedExprAssignOperator.minus:
+        return TokenType.MINUS;
+      case UnlinkedExprAssignOperator.shiftLeft:
+        return TokenType.LT_LT;
+      case UnlinkedExprAssignOperator.shiftRight:
+        return TokenType.GT_GT;
+      case UnlinkedExprAssignOperator.bitAnd:
+        return TokenType.AMPERSAND;
+      case UnlinkedExprAssignOperator.bitXor:
+        return TokenType.CARET;
+      case UnlinkedExprAssignOperator.bitOr:
+        return TokenType.BAR;
+      case UnlinkedExprAssignOperator.prefixIncrement:
+        return TokenType.PLUS_PLUS;
+      case UnlinkedExprAssignOperator.prefixDecrement:
+        return TokenType.MINUS_MINUS;
+      case UnlinkedExprAssignOperator.postfixIncrement:
+        return TokenType.PLUS_PLUS;
+      case UnlinkedExprAssignOperator.postfixDecrement:
+        return TokenType.MINUS_MINUS;
     }
+    return null;
   }
 }
 
 /**
  * Element representing a field resynthesized from a summary during
  * linking.
  */
 abstract class FieldElementForLink implements FieldElement {
   @override
   PropertyAccessorElementForLink get getter;
@@ skipping 1452 matching lines @@
           return element.type;
         }
       }
     }
     return DynamicTypeImpl.instance;
   }
 
   @override
   TypeInferenceNode get asTypeInferenceNode => _target.asTypeInferenceNode;
 
-  /**
-   * Return `true` if this element is an instance getter, or its target
-   * is an instance getter (recursively).
-   */
-  bool get hasInstanceGetterReference {
-    ExecutableElement element = asExecutableElement;
-    if (element is PropertyAccessorElement) {
-      return !element.isStatic;
-    }
-    ReferenceableElementForLink target = _target;
-    if (target is NonstaticMemberElementForLink) {
-      return target.hasInstanceGetterReference;
-    }
-    return false;
-  }
-
   @override
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_library, this, name);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$_target.(dynamic)$_name';
@@ skipping 822 matching lines @@
           break;
         case UnlinkedExprOperation.makeTypedList:
           refPtr++;
           intPtr++;
           break;
         case UnlinkedExprOperation.makeTypedMap:
           refPtr += 2;
           intPtr++;
           break;
         case UnlinkedExprOperation.assignToRef:
-          // TODO(paulberry): if this reference refers to a variable, should it
-          // be considered a type inference dependency?
-          refPtr++;
+          EntityRef ref = unlinkedConst.references[refPtr++];
+          // TODO(paulberry): cache these resolved references for
+          // later use by evaluate().
+          TypeInferenceNode dependency =
+              compilationUnit.resolveRef(ref.reference).asTypeInferenceNode;
+          if (dependency != null) {
+            dependencies.add(dependency);
+          }
           break;
         case UnlinkedExprOperation.invokeMethodRef:
           EntityRef ref = unlinkedConst.references[refPtr++];
           TypeInferenceNode dependency =
               compilationUnit.resolveRef(ref.reference).asTypeInferenceNode;
           if (dependency != null) {
             dependencies.add(dependency);
           }
           intPtr += 2;
           int numTypeArguments = unlinkedConst.ints[intPtr++];
@@ skipping 399 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
-
-/**
- * This exception is thrown when [ExprTypeComputer] cannot inference the type.
- */
-class _InferenceFailedError {
-  final String message;
-
-  _InferenceFailedError(this.message);
-}