Remove toplevel inference restriction hints, and restore as much

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'dart:collection';
 import 'package:analyzer/analyzer.dart';
@@ skipping 1222 matching lines @@
           }
         }
       }
     }
 
     void validateIdentifierElement(AstNode n, Element e) {
       if (e == null) {
         return;
       }
 
-      Element enclosing = e.enclosingElement;
-      if (enclosing is CompilationUnitElement) {
-        if (e is PropertyAccessorElement) {
-          validateHasType(e);
-        }
-      } else if (enclosing is ClassElement) {
-        if (e is PropertyAccessorElement) {
-          if (e.isStatic) {
-            validateHasType(e);
-          } else {
-            _recordMessage(
-                n, StrongModeCode.TOP_LEVEL_INSTANCE_GETTER, [name, e.name]);
-          }
-        }
+      if (e is PropertyAccessorElement) {
+        validateHasType(e);
       }
     }
 
     if (n == null ||
         n is NullLiteral ||
         n is BooleanLiteral ||
         n is DoubleLiteral ||
         n is IntegerLiteral ||
         n is StringLiteral ||
         n is SymbolLiteral ||
         n is IndexExpression) {
       // Nothing to validate.
     } else if (n is AwaitExpression) {
       _validateTopLevelInitializer(name, n.expression);
     } else if (n is ThrowExpression) {
       // Nothing to validate.
     } else if (n is ParenthesizedExpression) {
       _validateTopLevelInitializer(name, n.expression);
     } else if (n is ConditionalExpression) {
       _validateTopLevelInitializer(name, n.thenExpression);
       _validateTopLevelInitializer(name, n.elseExpression);
     } else if (n is BinaryExpression) {
       TokenType operator = n.operator.type;
       if (operator == TokenType.AMPERSAND_AMPERSAND ||
           operator == TokenType.BAR_BAR ||
           operator == TokenType.EQ_EQ ||
           operator == TokenType.BANG_EQ) {
         // These operators give 'bool', no need to validate operands.
       } else if (operator == TokenType.QUESTION_QUESTION) {
-        _recordMessage(n, StrongModeCode.TOP_LEVEL_UNSUPPORTED,
-            [name, n.runtimeType.toString()]);
+        _validateTopLevelInitializer(name, n.leftOperand);
+        _validateTopLevelInitializer(name, n.rightOperand);
       } else {
         _validateTopLevelInitializer(name, n.leftOperand);
       }
     } else if (n is PrefixExpression) {
       TokenType operator = n.operator.type;
       if (operator == TokenType.BANG) {
         // This operator gives 'bool', no need to validate operands.
       } else {
         _validateTopLevelInitializer(name, n.operand);
       }
     } else if (n is PostfixExpression) {
       _validateTopLevelInitializer(name, n.operand);
     } else if (n is ListLiteral) {
       if (n.typeArguments == null) {
         for (Expression element in n.elements) {
           _validateTopLevelInitializer(name, element);
         }
       }
     } else if (n is MapLiteral) {
       if (n.typeArguments == null) {
         for (MapLiteralEntry entry in n.entries) {
           _validateTopLevelInitializer(name, entry.key);
           _validateTopLevelInitializer(name, entry.value);
         }
       }
     } else if (n is FunctionExpression) {
-      for (FormalParameter p in n.parameters.parameters) {
-        if (p is DefaultFormalParameter) {
-          p = (p as DefaultFormalParameter).parameter;
-        }
-        if (p is SimpleFormalParameter) {
-          if (p.type == null) {
-            _recordMessage(
-                p,
-                StrongModeCode.TOP_LEVEL_FUNCTION_LITERAL_PARAMETER,
-                [name, p.element?.name]);
-          }
-        }
-      }
-
       FunctionBody body = n.body;
       if (body is ExpressionFunctionBody) {
         _validateTopLevelInitializer(name, body.expression);
       } else {
         _recordMessage(n, StrongModeCode.TOP_LEVEL_FUNCTION_LITERAL_BLOCK, []);
       }
     } else if (n is InstanceCreationExpression) {
-      ConstructorElement constructor = n.staticElement;
-      ClassElement clazz = constructor?.enclosingElement;
-      if (clazz != null && clazz.typeParameters.isNotEmpty) {
-        TypeName type = n.constructorName.type;
-        if (type.typeArguments == null) {
-          _recordMessage(type, StrongModeCode.TOP_LEVEL_TYPE_ARGUMENTS,
-              [name, clazz.name]);
-        }
-      }
+      // Nothing to validate.
     } else if (n is AsExpression) {
       // Nothing to validate.
     } else if (n is IsExpression) {
       // Nothing to validate.
     } else if (n is Identifier) {
       validateIdentifierElement(n, n.staticElement);
     } else if (n is PropertyAccess) {
       Element element = n.propertyName.staticElement;
       validateIdentifierElement(n.propertyName, element);
     } else if (n is FunctionExpressionInvocation) {
       _validateTopLevelInitializer(name, n.function);
-      // TODO(scheglov) type arguments
     } else if (n is MethodInvocation) {
       _validateTopLevelInitializer(name, n.target);
-      SimpleIdentifier methodName = n.methodName;
-      Element element = methodName.staticElement;
-      if (element is ExecutableElement && element.typeParameters.isNotEmpty) {
-        if (n.typeArguments == null) {
-          _recordMessage(methodName, StrongModeCode.TOP_LEVEL_TYPE_ARGUMENTS,
-              [name, methodName.name]);
-        }
-      }
     } else if (n is CascadeExpression) {
       _validateTopLevelInitializer(name, n.target);
-    } else {
-      _recordMessage(n, StrongModeCode.TOP_LEVEL_UNSUPPORTED,
-          [name, n.runtimeType.toString()]);
     }
   }
 }
 
 /// Checks for overriding declarations of fields and methods. This is used to
 /// check overrides between classes and superclasses, interfaces, and mixin
 /// applications.
 class _OverrideChecker {
   final StrongTypeSystemImpl rules;
   final CodeChecker _checker;
@@ skipping 620 matching lines @@
   }
 
   /// If node is a [ClassDeclaration] returns its members, otherwise if node is
   /// a [ClassTypeAlias] this returns an empty list.
   WithClause _withClause(Declaration node) {
     return node is ClassDeclaration
         ? node.withClause
         : (node as ClassTypeAlias).withClause;
   }
 }