Clean-up imports

pkg/analyzer/lib/src/task/strong/info.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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.info;
 
+import 'package:analyzer/dart/ast/ast.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/generated/ast.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/type_system.dart';
 
 // A down cast due to a variable declaration to a ground type.  E.g.,
 //   T x = expr;
 // where T is ground.  We exclude non-ground types as these behave differently
 // compared to standard Dart.
 class AssignmentCast extends DownCast {
   AssignmentCast(TypeSystem rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
@@ skipping 63 matching lines @@
   DownCast._internal(TypeSystem rules, Expression expression, this._cast)
       : super(rules, expression) {
     assert(_cast.toType != baseType &&
         _cast.fromType == baseType &&
         (baseType.isDynamic ||
             // Call methods make the following non-redundant
             _cast.toType.isSubtypeOf(baseType) ||
             baseType.isAssignableTo(_cast.toType)));
   }
 
-  @override List<Object> get arguments => [node, baseType, convertedType];
+  @override
+  List<Object> get arguments => [node, baseType, convertedType];
 
   Cast get cast => _cast;
 
   DartType get convertedType => _cast.toType;
-  @override String get message => '{0} ({1}) will need runtime check '
+  @override
+  String get message => '{0} ({1}) will need runtime check '
       'to cast to type {2}';
 
   // Factory to create correct DownCast variant.
   static StaticInfo create(
       StrongTypeSystemImpl rules, Expression expression, Cast cast,
       {String reason}) {
     final fromT = cast.fromType;
     final toT = cast.toType;
 
     // toT <:_R fromT => to <: fromT
@@ skipping 174 matching lines @@
 
 // An inferred type for the wrapped expression, which may need to be
 // reified into the term
 abstract class InferredTypeBase extends CoercionInfo {
   final DartType _type;
 
   InferredTypeBase._internal(
       TypeSystem rules, Expression expression, this._type)
       : super(rules, expression);
 
-  @override List get arguments => [node, type];
+  @override
+  List get arguments => [node, type];
   DartType get convertedType => type;
-  @override String get message => '{0} has inferred type {1}';
+  @override
+  String get message => '{0} has inferred type {1}';
   DartType get type => _type;
 
   toErrorCode() => new HintCode(name, message);
 }
 
 // An inferred type for a closure expression
 class InferredTypeClosure extends InferredTypeBase {
   InferredTypeClosure(TypeSystem rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 
@@ skipping 55 matching lines @@
   /// Whether the error comes from a mixin (either overriding a base class or an
   /// interface declaration).
   final bool fromMixin;
 
   InvalidOverride(
       AstNode node, this.element, this.base, this.subType, this.baseType)
       : fromBaseClass = node is ExtendsClause,
         fromMixin = node.parent is WithClause,
         super(node);
 
-  @override List<Object> get arguments =>
+  @override
+  List<Object> get arguments =>
       [parent.name, element.name, subType, base, baseType];
 
   ClassElement get parent => element.enclosingElement;
 
   String _messageHelper(String errorName) {
     var lcErrorName = errorName.toLowerCase();
     var intro = fromBaseClass
         ? 'Base class introduces an $lcErrorName'
         : (fromMixin ? 'Mixin introduces an $lcErrorName' : errorName);
     return '$intro. The type of {0}.{1} ({2}) is not a '
         'subtype of {3}.{1} ({4}).';
   }
 }
 
 class InvalidParameterDeclaration extends StaticError {
   final DartType expectedType;
 
   InvalidParameterDeclaration(
       TypeSystem rules, FormalParameter declaration, this.expectedType)
       : super(declaration);
 
-  @override List<Object> get arguments => [node, expectedType];
-  @override String get message => 'Type check failed: {0} is not of type {1}';
+  @override
+  List<Object> get arguments => [node, expectedType];
+  @override
+  String get message => 'Type check failed: {0} is not of type {1}';
   @override
   String get name => 'STRONG_MODE_INVALID_PARAMETER_DECLARATION';
 }
 
 /// Dart constructors have one weird quirk, illustrated with this example:
 ///
 ///     class Base {
 ///       var x;
 ///       Base() : x = print('Base.1') {
 ///         print('Base.2');
@@ skipping 16 matching lines @@
 /// immediately after super initializers. Normally this isn't observable, but it
 /// could be if initializers have side effects.
 ///
 /// Better to have `super` at the end, as required by the Dart style guide:
 /// <http://goo.gl/q1T4BB>
 ///
 /// For now this is the only pattern we support.
 class InvalidSuperInvocation extends StaticError {
   InvalidSuperInvocation(SuperConstructorInvocation node) : super(node);
 
-  @override String get message => "super call must be last in an initializer "
+  @override
+  String get message => "super call must be last in an initializer "
       "list (see http://goo.gl/q1T4BB): {0}";
 
   @override
   String get name => 'STRONG_MODE_INVALID_SUPER_INVOCATION';
 }
 
 class InvalidVariableDeclaration extends StaticError {
   final DartType expectedType;
 
   InvalidVariableDeclaration(
       TypeSystem rules, AstNode declaration, this.expectedType)
       : super(declaration);
 
-  @override List<Object> get arguments => [expectedType];
-  @override String get message => 'Type check failed: null is not of type {0}';
+  @override
+  List<Object> get arguments => [expectedType];
+  @override
+  String get message => 'Type check failed: null is not of type {0}';
 
   @override
   String get name => 'STRONG_MODE_INVALID_VARIABLE_DECLARATION';
 }
 
 class NonGroundTypeCheckInfo extends StaticInfo {
   final DartType type;
   final AstNode node;
 
   NonGroundTypeCheckInfo(this.node, this.type) {
     assert(node is IsExpression || node is AsExpression);
   }
 
-  @override List<Object> get arguments => [type];
+  @override
+  List<Object> get arguments => [type];
   String get message =>
       "Runtime check on non-ground type {0} may throw StrongModeError";
 
   @override
   String get name => 'STRONG_MODE_NON_GROUND_TYPE_CHECK_INFO';
 
   toErrorCode() => new HintCode(name, message);
 }
 
 abstract class StaticError extends StaticInfo {
@@ skipping 61 matching lines @@
 class StaticTypeError extends StaticError {
   final DartType baseType;
   final DartType expectedType;
   String reason = null;
 
   StaticTypeError(TypeSystem rules, Expression expression, this.expectedType,
       {this.reason})
       : baseType = expression.staticType ?? DynamicTypeImpl.instance,
         super(expression);
 
-  @override List<Object> get arguments => [node, baseType, expectedType];
-  @override String get message =>
+  @override
+  List<Object> get arguments => [node, baseType, expectedType];
+  @override
+  String get message =>
       'Type check failed: {0} ({1}) is not of type {2}' +
       ((reason == null) ? '' : ' because $reason');
 
   @override
   String get name => 'STRONG_MODE_STATIC_TYPE_ERROR';
 }
 
 //
 // Temporary "casts" of allocation sites - literals, constructor invocations,
 // and closures.  These should be handled by contextual inference.  In most
 // cases, inference will be sufficient, though in some it may unmask an actual
 // error: e.g.,
 //   List<int> l = [1, 2, 3]; // Inference succeeds
 //   List<String> l = [1, 2, 3]; // Inference reveals static type error
 // We're marking all as warnings for now.
 //
 // TODO(vsm,leafp): Remove this.
 class UninferredClosure extends DownCast {
   UninferredClosure(TypeSystem rules, FunctionExpression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   @override
   String get name => 'STRONG_MODE_UNINFERRED_CLOSURE';
 
   toErrorCode() => new StaticTypeWarningCode(name, message);
 }