Remove toplevel inference restriction hints, and restore as much

pkg/analyzer/lib/src/task/strong_mode.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.src.task.strong_mode;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, InheritanceManager;
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart'
     show FieldElementForLink_ClassField, ParameterElementForLink;
 
 /**
- * Return `true` if the given [expression] is an immediately-evident expression,
- * so can be used to infer the type for a top-level variable or a class field.
- */
-bool isValidForTypeInference(Expression expression) {
-  var visitor = new _IsValidForTypeInferenceVisitor();
-  expression.accept(visitor);
-  return visitor.isValid;
-}
-
-/**
  * Sets the type of the field. The types in implicit accessors are updated
  * implicitly, and the types of explicit accessors should be updated separately.
  */
 void setFieldType(VariableElement field, DartType newType) {
   (field as VariableElementImpl).type = newType;
 }
 
 /**
  * A function that return the [InheritanceManager] for the class [element].
  */
@@ skipping 18 matching lines @@
    * The type system used to compute the least upper bound of types.
    */
   TypeSystem typeSystem;
 
   /**
    * The provider for inheritance managers used to find overridden method.
    */
   final InheritanceManagerProvider inheritanceManagerProvider;
 
   /**
-   * The set of fields for which type inference from initializer should be
-   * disabled, because their initializers are not immediately-evident
-   * expressions.
-   */
-  final Set<FieldElement> fieldsWithDisabledInitializerInference;
-
-  /**
    * The classes that have been visited while attempting to infer the types of
    * instance members of some base class.
    */
   HashSet<ClassElementImpl> elementsBeingInferred =
       new HashSet<ClassElementImpl>();
 
   /**
    * Initialize a newly create inferrer.
    */
   InstanceMemberInferrer(
-      TypeProvider typeProvider,
-      this.inheritanceManagerProvider,
-      this.fieldsWithDisabledInitializerInference,
+      TypeProvider typeProvider, this.inheritanceManagerProvider,
       {TypeSystem typeSystem})
       : typeSystem = (typeSystem != null)
             ? typeSystem
             : new TypeSystemImpl(typeProvider),
         this.typeProvider = typeProvider;
 
   /**
    * Infer type information for all of the instance members in the given
    * compilation [unit].
    */
@@ skipping 319 matching lines @@
     if (typeResult.isError) {
       if (field is FieldElementForLink_ClassField) {
         field.setInferenceError(new TopLevelInferenceErrorBuilder(
             kind: TopLevelInferenceErrorKind.overrideConflictFieldType));
       }
       return;
     }
 
     if (field.hasImplicitType) {
       DartType newType = typeResult.type;
-      if (newType == null &&
-          field.initializer != null &&
-          !fieldsWithDisabledInitializerInference.contains(field)) {
+      if (newType == null && field.initializer != null) {
         newType = field.initializer.returnType;
       }
 
       if (newType == null || newType.isBottom || newType.isDartCoreNull) {
         newType = typeProvider.dynamicType;
       }
 
       setFieldType(field, newType);
     }
 
@@ skipping 155 matching lines @@
 /**
  * The result of field type inference.
  */
 class _FieldOverrideInferenceResult {
   final bool isCovariant;
   final DartType type;
   final bool isError;
 
   _FieldOverrideInferenceResult(this.isCovariant, this.type, this.isError);
 }
-
-/**
- * The visitor for [isValidForTypeInference].
- */
-class _IsValidForTypeInferenceVisitor extends RecursiveAstVisitor {
-  bool isValid = true;
-
-  @override
-  void visitAssignmentExpression(AssignmentExpression node) {
-    isValid = false;
-  }
-
-  @override
-  void visitCascadeExpression(CascadeExpression node) {
-    node.target.accept(this);
-  }
-
-  @override
-  void visitFunctionExpression(FunctionExpression node) {
-    FunctionBody body = node.body;
-    if (body is ExpressionFunctionBody) {
-      body.accept(this);
-    } else {
-      isValid = false;
-    }
-  }
-
-  @override
-  void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
-    node.function?.accept(this);
-  }
-
-  @override
-  void visitIndexExpression(IndexExpression node) {
-    isValid = false;
-  }
-
-  @override
-  void visitInstanceCreationExpression(InstanceCreationExpression node) {
-    ConstructorElement constructor = node.staticElement;
-    if (constructor != null) {
-      ClassElement clazz = constructor?.enclosingElement;
-      if (clazz.typeParameters.isNotEmpty &&
-          node.constructorName.type.typeArguments == null) {
-        isValid = false;
-        return;
-      }
-    }
-  }
-
-  @override
-  void visitListLiteral(ListLiteral node) {
-    if (node.typeArguments == null) {
-      super.visitListLiteral(node);
-    }
-  }
-
-  @override
-  void visitMapLiteral(MapLiteral node) {
-    if (node.typeArguments == null) {
-      super.visitMapLiteral(node);
-    }
-  }
-
-  @override
-  void visitMethodInvocation(MethodInvocation node) {
-    Element element = node.methodName.staticElement;
-    if (element is ExecutableElement) {
-      if (element.type.typeFormals.isNotEmpty && node.typeArguments == null) {
-        isValid = false;
-        return;
-      }
-    }
-    node.target?.accept(this);
-  }
-
-  @override
-  void visitSimpleIdentifier(SimpleIdentifier node) {
-    Element element = node.staticElement;
-    if (element == null) {
-      AstNode parent = node.parent;
-      if (parent is PropertyAccess && parent.propertyName == node ||
-          parent is PrefixedIdentifier && parent.identifier == node) {
-        isValid = false;
-      }
-    } else if (element is PropertyAccessorElement && !element.isStatic) {
-      isValid = false;
-    }
-  }
-}