Break up another large file

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 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/ast/token.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/type.dart';
+import 'package:analyzer/src/error/codes.dart' show StrongModeCode;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
-import 'package:analyzer/src/generated/error.dart' show StrongModeCode;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/type_system.dart';
 
 import 'ast_properties.dart';
 
-bool isKnownFunction(Expression expression) {
-  var element = _getKnownElement(expression);
-  // First class functions and static methods, where we know the original
-  // declaration, will have an exact type, so we know a downcast will fail.
-  return element is FunctionElement ||
-      element is MethodElement && element.isStatic;
-}
-
 /// Given an [expression] and a corresponding [typeSystem] and [typeProvider],
 /// gets the known static type of the expression.
 ///
 /// Normally when we ask for an expression's type, we get the type of the
 /// storage slot that would contain it. For function types, this is necessarily
 /// a "fuzzy arrow" that treats `dynamic` as bottom. However, if we're
 /// interested in the expression's own type, it can often be a "strict arrow"
 /// because we know it evaluates to a specific, concrete function, and we can
 /// treat "dynamic" as top for that case, which is more permissive.
 DartType getDefiniteType(
     Expression expression, TypeSystem typeSystem, TypeProvider typeProvider) {
   DartType type = expression.staticType ?? DynamicTypeImpl.instance;
   if (typeSystem is StrongTypeSystemImpl &&
       type is FunctionType &&
       _hasStrictArrow(expression)) {
     // Remove fuzzy arrow if possible.
     return typeSystem.functionTypeToConcreteType(typeProvider, type);
   }
   return type;
 }
 
-bool _hasStrictArrow(Expression expression) {
+bool isKnownFunction(Expression expression) {
   var element = _getKnownElement(expression);
-  return element is FunctionElement || element is MethodElement;
+  // First class functions and static methods, where we know the original
+  // declaration, will have an exact type, so we know a downcast will fail.
+  return element is FunctionElement ||
+      element is MethodElement && element.isStatic;
+}
+
+DartType _elementType(Element e) {
+  if (e == null) {
+    // Malformed code - just return dynamic.
+    return DynamicTypeImpl.instance;
+  }
+  return (e as dynamic).type;
 }
 
 Element _getKnownElement(Expression expression) {
   if (expression is ParenthesizedExpression) {
     expression = (expression as ParenthesizedExpression).expression;
   }
   if (expression is FunctionExpression) {
     return expression.element;
   } else if (expression is PropertyAccess) {
     return expression.propertyName.staticElement;
   } else if (expression is Identifier) {
     return expression.staticElement;
   }
   return null;
 }
 
-DartType _elementType(Element e) {
-  if (e == null) {
-    // Malformed code - just return dynamic.
-    return DynamicTypeImpl.instance;
-  }
-  return (e as dynamic).type;
-}
-
-// Return the field on type corresponding to member, or null if none
-// exists or the "field" is actually a getter/setter.
+/// Return the field on type corresponding to member, or null if none
+/// exists or the "field" is actually a getter/setter.
 PropertyInducingElement _getMemberField(
     InterfaceType type, PropertyAccessorElement member) {
   String memberName = member.name;
   PropertyInducingElement field;
   if (member.isGetter) {
     // The subclass member is an explicit getter or a field
     // - lookup the getter on the superclass.
     var getter = type.getGetter(memberName);
     if (getter == null || getter.isStatic) return null;
     field = getter.variable;
@@ skipping 10 matching lines @@
   }
   if (field.isSynthetic) return null;
   return field;
 }
 
 /// Looks up the declaration that matches [member] in [type] and returns it's
 /// declared type.
 FunctionType _getMemberType(InterfaceType type, ExecutableElement member) =>
     _memberTypeGetter(member)(type);
 
+bool _hasStrictArrow(Expression expression) {
+  var element = _getKnownElement(expression);
+  return element is FunctionElement || element is MethodElement;
+}
+
 _MemberTypeGetter _memberTypeGetter(ExecutableElement member) {
   String memberName = member.name;
   final isGetter = member is PropertyAccessorElement && member.isGetter;
   final isSetter = member is PropertyAccessorElement && member.isSetter;
 
   FunctionType f(InterfaceType type) {
     ExecutableElement baseMethod;
 
     if (member.isPrivate) {
       var subtypeLibrary = member.library;
@@ skipping 511 matching lines @@
   @override
   void visitSwitchStatement(SwitchStatement node) {
     // SwitchStatement defines a boolean conversion to check the result of the
     // case value == the switch value, but in dev_compiler we require a boolean
     // return type from an overridden == operator (because Object.==), so
     // checking in SwitchStatement shouldn't be necessary.
     node.visitChildren(this);
   }
 
   @override
+  Object visitVariableDeclaration(VariableDeclaration node) {
+    if (!node.isConst &&
+        !node.isFinal &&
+        node.initializer == null &&
+        rules.isNonNullableType(node?.element?.type)) {
+      _recordMessage(
+          node,
+          StaticTypeWarningCode.NON_NULLABLE_FIELD_NOT_INITIALIZED,
+          [node.name, node?.element?.type]);
+    }
+    return super.visitVariableDeclaration(node);
+  }
+
+  @override
   void visitVariableDeclarationList(VariableDeclarationList node) {
     TypeName type = node.type;
     if (type == null) {
       // No checks are needed when the type is var. Although internally the
       // typing rules may have inferred a more precise type for the variable
       // based on the initializer.
     } else {
       for (VariableDeclaration variable in node.variables) {
         var initializer = variable.initializer;
         if (initializer != null) {
           checkAssignment(initializer, type.type);
         }
       }
     }
     node.visitChildren(this);
   }
 
   @override
-  Object visitVariableDeclaration(VariableDeclaration node) {
-    if (!node.isConst &&
-        !node.isFinal &&
-        node.initializer == null &&
-        rules.isNonNullableType(node?.element?.type)) {
-      _recordMessage(
-          node,
-          StaticTypeWarningCode.NON_NULLABLE_FIELD_NOT_INITIALIZED,
-          [node.name, node?.element?.type]);
-    }
-    return super.visitVariableDeclaration(node);
-  }
-
-  @override
   void visitWhileStatement(WhileStatement node) {
     checkBoolean(node.condition);
     node.visitChildren(this);
   }
 
   @override
   void visitYieldStatement(YieldStatement node) {
     _checkReturnOrYield(node.expression, node, yieldStar: node.star != null);
     node.visitChildren(this);
   }
@@ skipping 185 matching lines @@
       // Variable declaration is inside a function or method, so it's safe.
       return;
     }
     _recordMessage(node, StrongModeCode.UNSAFE_BLOCK_CLOSURE_INFERENCE,
         [declElement.name]);
   }
 
   /// Checks if the assignment is valid with respect to non-nullable types.
   /// Returns `false` if a nullable expression is assigned to a variable of
   /// non-nullable type and `true` otherwise.
-  bool _checkNonNullAssignment(Expression expression, DartType to, DartType from) {
+  bool _checkNonNullAssignment(
+      Expression expression, DartType to, DartType from) {
     if (rules.isNonNullableType(to) && rules.isNullableType(from)) {
-      _recordMessage(expression, StaticTypeWarningCode.INVALID_ASSIGNMENT,
-          [from, to]);
+      _recordMessage(
+          expression, StaticTypeWarningCode.INVALID_ASSIGNMENT, [from, to]);
       return false;
     }
     return true;
   }
 
   void _checkReturnOrYield(Expression expression, AstNode node,
       {bool yieldStar: false}) {
     FunctionBody body = node.getAncestor((n) => n is FunctionBody);
     var type = _getExpectedReturnType(body, yieldStar: yieldStar);
     if (type == null) {
@@ skipping 22 matching lines @@
         op.type == TokenType.MINUS_MINUS) {
       if (element == null) {
         _recordDynamicInvoke(node, node.operand);
       }
       // For ++ and --, even if it is not dynamic, we still need to check
       // that the user defined method accepts an `int` as the RHS.
       // We assume Analyzer has done this already.
     }
   }
 
+  DartType _getDefiniteType(Expression expr) =>
+      getDefiniteType(expr, rules, typeProvider);
+
   /// Gets the expected return type of the given function [body], either from
   /// a normal return/yield, or from a yield*.
   DartType _getExpectedReturnType(FunctionBody body, {bool yieldStar: false}) {
     FunctionType functionType;
     var parent = body.parent;
     if (parent is Declaration) {
       functionType = _elementType(parent.element);
     } else {
       assert(parent is FunctionExpression);
       functionType =
@@ skipping 34 matching lines @@
     if (type.isDynamic) {
       return type;
     } else if (type is InterfaceType && type.element == expectedType.element) {
       return type.typeArguments[0];
     } else {
       // Malformed type - fallback on analyzer error.
       return null;
     }
   }
 
-  DartType _getDefiniteType(Expression expr) =>
-      getDefiniteType(expr, rules, typeProvider);
-
   /// Given an expression, return its type assuming it is
   /// in the caller position of a call (that is, accounting
   /// for the possibility of a call method).  Returns null
   /// if expression is not statically callable.
   FunctionType _getTypeAsCaller(InvocationExpression node) {
     DartType type = node.staticInvokeType;
     if (type is FunctionType) {
       return type;
     } else if (type is InterfaceType) {
       return rules.getCallMethodType(type);
@@ skipping 469 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }