Fail inference when an instance field is referenced.

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 1965 matching lines @@
   final Linker linker;
   final TypeProvider typeProvider;
   final UnlinkedExpr unlinkedConst;
 
   final List<DartType> stack = <DartType>[];
   int intPtr = 0;
   int refPtr = 0;
   int strPtr = 0;
   int assignmentOperatorPtr = 0;
 
+  bool hasError = false;
+
   factory ExprTypeComputer(FunctionElementForLink_Local functionElement) {
     CompilationUnitElementForLink unit = functionElement.compilationUnit;
     LibraryElementForLink library = unit.enclosingElement;
     Linker linker = library._linker;
     TypeProvider typeProvider = linker.typeProvider;
     UnlinkedExpr unlinkedConst = functionElement._unlinkedExecutable.bodyExpr;
     return new ExprTypeComputer._(
         functionElement, unit, library, linker, typeProvider, unlinkedConst);
   }
 
@@ skipping 44 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:
-          _doPushReference();
+          try {
+            _doPushReference();
+          } on _InferenceFailedError {
+            hasError = true;
+            return DynamicTypeImpl.instance;
+          }
           break;
         case UnlinkedExprOperation.extractProperty:
-          _doExtractProperty();
+          try {
+            _doExtractProperty();
+          } on _InferenceFailedError {
+            hasError = true;
+            return DynamicTypeImpl.instance;
+          }
           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.assignToRef:
-          _doAssignToRef();
+          try {
+            _doAssignToRef();
+          } on _InferenceFailedError {
+            hasError = true;
+            return DynamicTypeImpl.instance;
+          }
           break;
         case UnlinkedExprOperation.assignToProperty:
-          _doAssignToProperty();
+          try {
+            _doAssignToProperty();
+          } on _InferenceFailedError {
+            hasError = true;
+            return DynamicTypeImpl.instance;
+          }
           break;
         case UnlinkedExprOperation.assignToIndex:
           _doAssignToIndex();
           break;
         case UnlinkedExprOperation.await:
           _doAwait();
           break;
         case UnlinkedExprOperation.extractIndex:
           _doExtractIndex();
           break;
         case UnlinkedExprOperation.invokeMethodRef:
-          _doInvokeMethodRef();
+          try {
+            _doInvokeMethodRef();
+          } on _InferenceFailedError {
+            hasError = true;
+            return DynamicTypeImpl.instance;
+          }
           break;
         case UnlinkedExprOperation.invokeMethod:
           _doInvokeMethod();
           break;
         case UnlinkedExprOperation.cascadeSectionBegin:
           stack.add(stack.last);
           break;
         case UnlinkedExprOperation.cascadeSectionEnd:
           stack.removeLast();
           break;
@@ skipping 66 matching lines @@
     } else if (isIncrementOrDecrement(operator)) {
       // TODO(scheglov) implement
       stack.add(DynamicTypeImpl.instance);
     } else {
       stack.removeLast();
       // TODO(scheglov) implement
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
+  void _throwIfInstanceFieldOrAccessor(Object element) {
+//    if (element is NonstaticMemberElementForLink) {
+//      element = (element as NonstaticMemberElementForLink).asExecutableElement;
+//    }
+    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.');
+    }
+  }
+
   void _doAssignToProperty() {
+//    if (!element.isStatic) {
+    throw new _InferenceFailedError(
+        'Instance fields cannot be used for type inference.');
+//    }
     DartType targetType = stack.removeLast();
     String propertyName = _getNextString();
     UnlinkedExprAssignOperator assignOperator =
         unlinkedConst.assignmentOperators[assignmentOperatorPtr++];
     if (assignOperator == UnlinkedExprAssignOperator.assign) {
       // The type of the assignment is the type of the value,
       // which is already in the stack.
     } else if (assignOperator == UnlinkedExprAssignOperator.postfixDecrement ||
         assignOperator == UnlinkedExprAssignOperator.postfixIncrement) {
       DartType propertyType = _getPropertyType(targetType, propertyName);
       stack.add(propertyType);
     } else if (assignOperator == UnlinkedExprAssignOperator.prefixDecrement) {
       _pushPropertyBinaryExpression(
           targetType, propertyName, TokenType.MINUS, typeProvider.intType);
     } else if (assignOperator == UnlinkedExprAssignOperator.prefixIncrement) {
       _pushPropertyBinaryExpression(
           targetType, propertyName, TokenType.PLUS, typeProvider.intType);
     } else {
       TokenType binaryOperator =
           _convertAssignOperatorToTokenType(assignOperator);
       DartType operandType = stack.removeLast();
       _pushPropertyBinaryExpression(
           targetType, propertyName, binaryOperator, operandType);
     }
   }
 
   void _doAssignToRef() {
-    refPtr++;
+    EntityRef ref = _getNextRef();
+    ReferenceableElementForLink element = unit.resolveRef(ref.reference);
+    _throwIfInstanceFieldOrAccessor(element);
     UnlinkedExprAssignOperator operator =
         unlinkedConst.assignmentOperators[assignmentOperatorPtr++];
     if (operator == UnlinkedExprAssignOperator.assign) {
       // The type of the assignment is the type of the value,
       // which is already in the stack.
     } else if (isIncrementOrDecrement(operator)) {
       // TODO(scheglov) implement
       stack.add(DynamicTypeImpl.instance);
     } else {
       stack.removeLast();
@@ skipping 37 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;
     }());
@@ skipping 95 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 1404 matching lines @@
    * The name of the non-static members that is being accessed.
    */
   final String _name;
 
   /**
    * The library in which the access occurs.  This determines whether private
    * names are accessible.
    */
   final LibraryElementForLink _library;
 
+  bool _elementReady = false;
+  ExecutableElement _element;
+
   NonstaticMemberElementForLink(this._library, this._target, this._name);
 
   @override
   ConstVariableNode get asConstVariable => _target.asConstVariable;
 
-  @override
-  DartType get asStaticType {
-    if (_library._linker.strongMode) {
+  /**
+   * TODO(scheglov) document
+   */
+  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;
+  }
+
+  /**
+   * TODO((scheglov) document
+   */
+  ExecutableElement get asExecutableElement {
+    if (!_elementReady) {
+      _elementReady = true;
       DartType targetType = _target.asStaticType;
       if (targetType.isDynamic) {
         targetType = _library._linker.typeProvider.objectType;
       }
       if (targetType is InterfaceType) {
-        ExecutableElement element =
+        _element =
             targetType.lookUpInheritedGetterOrMethod(_name, library: _library);
-        if (element != null) {
-          if (element is PropertyAccessorElement) {
-            return element.returnType;
-          } else {
-            // Method tear-off
-            return element.type;
-          }
-        }
       }
       // TODO(paulberry): handle .call on function types and .toString or
       // .hashCode on all types.
     }
+    return _element;
+  }
+
+  @override
+  DartType get asStaticType {
+    if (_library._linker.strongMode) {
+      ExecutableElement element = asExecutableElement;
+      if (element != null) {
+        if (element is PropertyAccessorElement) {
+          return element.returnType;
+        } else {
+          // Method tear-off
+          return element.type;
+        }
+      }
+    }
     return DynamicTypeImpl.instance;
   }
 
   @override
   TypeInferenceNode get asTypeInferenceNode => _target.asTypeInferenceNode;
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_library, this, name);
   }
@@ skipping 490 matching lines @@
   List<TypeParameterElement> get typeParameters {
     // TODO(paulberry): is this correct for fields in generic classes?
     return const [];
   }
 
   /**
    * Compute the type of the corresponding variable, which may depend on the
    * progress of type inference.
    */
   DartType computeVariableType() {
-    if (variable.hasImplicitType &&
-        !isStatic &&
-        !variable.compilationUnit.isTypeInferenceComplete) {
-      // This is an instance field and we are currently inferring types in the
-      // library cycle containing it.  So we shouldn't use the inferred type
-      // (even if we have already computed it), since that would lead to
-      // non-deterministic type inference results.
-      return DynamicTypeImpl.instance;
-    } else {
-      return variable.type;
-    }
+//    if (variable.hasImplicitType &&
+//        !isStatic &&
+//        !variable.compilationUnit.isTypeInferenceComplete) {
+//      // This is an instance field and we are currently inferring types in the
+//      // library cycle containing it.  So we shouldn't use the inferred type
+//      // (even if we have already computed it), since that would lead to
+//      // non-deterministic type inference results.
+//      return DynamicTypeImpl.instance;
+//    } else {
+    return variable.type;
+//    }
   }
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(library, this, name);
   }
 
   @override
   FunctionElementForLink_Local getLocalFunction(int index) {
     if (index == 0) {
@@ skipping 238 matching lines @@
 /**
  * Specialization of [Node] used to construct the type inference dependency
  * graph.
  */
 class TypeInferenceNode extends Node<TypeInferenceNode> {
   /**
    * The [FunctionElementForLink_Local] to which this node refers.
    */
   final FunctionElementForLink_Local functionElement;
 
+  /**
+   * TODO(scheglov) document
+   */
+  bool _hasError = false;
+
   TypeInferenceNode(this.functionElement);
 
   @override
   bool get isEvaluated => functionElement._hasTypeBeenInferred;
 
   /**
    * Collect the type inference dependencies in [unlinkedExecutable] (which
    * should be interpreted relative to [compilationUnit]) and store them in
    * [dependencies].
    */
@@ skipping 17 matching lines @@
           int numInts = unlinkedConst.ints[intPtr++];
           intPtr += numInts;
           break;
         case UnlinkedExprOperation.concatenate:
           intPtr++;
           break;
         case UnlinkedExprOperation.pushReference:
           EntityRef ref = unlinkedConst.references[refPtr++];
           // TODO(paulberry): cache these resolved references for
           // later use by evaluate().
-          TypeInferenceNode dependency =
-              compilationUnit.resolveRef(ref.reference).asTypeInferenceNode;
+          ReferenceableElementForLink element =
+              compilationUnit.resolveRef(ref.reference);
+//          // Type inference using instance fields is not allowed.
+//          // So, we need to report an error and fail the inference.
+//          if (element is VariableElementForLink) {
+//            var variable = element as VariableElementForLink;
+//            if (!variable.isStatic) {
+//              _hasError = true;
+//              dependencies.clear();
+//              return;
+//            }
+//          }
+          TypeInferenceNode dependency = element.asTypeInferenceNode;
           if (dependency != null) {
             dependencies.add(dependency);
           }
           break;
         case UnlinkedExprOperation.invokeConstructor:
           refPtr++;
           intPtr += 2;
           break;
         case UnlinkedExprOperation.makeUntypedList:
         case UnlinkedExprOperation.makeUntypedMap:
@@ skipping 49 matching lines @@
     List<TypeInferenceNode> dependencies = <TypeInferenceNode>[];
     collectDependencies(dependencies, functionElement._unlinkedExecutable,
         functionElement.compilationUnit);
     return dependencies;
   }
 
   void evaluate(bool inCycle) {
     if (inCycle) {
       functionElement._setInferredType(DynamicTypeImpl.instance);
     } else {
-      var bodyType = new ExprTypeComputer(functionElement).compute();
-      if (functionElement.isAsynchronous) {
-        var linker = functionElement.compilationUnit.library._linker;
-        var typeProvider = linker.typeProvider;
-        var typeSystem = linker.typeSystem;
-        if (bodyType.isDartAsyncFutureOr) {
-          bodyType = (bodyType as InterfaceType).typeArguments[0];
+      var computer = new ExprTypeComputer(functionElement);
+      if (computer.hasError) {
+        functionElement._setInferredType(DynamicTypeImpl.instance);
+      } else {
+        DartType bodyType = computer.compute();
+        if (functionElement.isAsynchronous) {
+          var linker = functionElement.compilationUnit.library._linker;
+          var typeProvider = linker.typeProvider;
+          var typeSystem = linker.typeSystem;
+          if (bodyType.isDartAsyncFutureOr) {
+            bodyType = (bodyType as InterfaceType).typeArguments[0];
+          }
+          bodyType = typeProvider.futureType
+              .instantiate([bodyType.flattenFutures(typeSystem)]);
         }
-        bodyType = typeProvider.futureType
-            .instantiate([bodyType.flattenFutures(typeSystem)]);
+        functionElement._setInferredType(bodyType);
       }
-      functionElement._setInferredType(bodyType);
     }
   }
 
   @override
   String toString() => 'TypeInferenceNode($functionElement)';
 }
 
 class TypeProviderForLink extends TypeProviderBase {
   final Linker _linker;
 
@@ skipping 311 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
+
+/**
+ * TODO(scheglov) document
+ */
+class _InferenceFailedError {
+  final String message;
+
+  _InferenceFailedError(this.message);
+}