Align strong-mode error codes with analyzer conv.

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/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
 
 import 'rules.dart';
 
 // The abstract type of coercions mapping one type to another.
 // This class also exposes static builder functions which
 // check for errors and reduce redundant coercions to the identity.

[Leaf, 2015/12/04 19:01:11]

I think something went very wrong with the sorting of members in this file.  All
of the comments for the classes stayed behind and are now out of place. 
Possibly partially our fault for not using doc comments?  Not sure all comments
outside of classes should be doc comments though, so not sure what the right
answer is.  

[pquitslund, 2015/12/04 19:13:33]

Yep.  In this case, I think doc comments make sense but in general we need to
fix the sorter to be smarter.

-abstract class Coercion {
-  final DartType fromType;
-  final DartType toType;
-  Coercion(this.fromType, this.toType);
-  static Coercion cast(DartType fromT, DartType toT) => new Cast(fromT, toT);
-  static Coercion identity(DartType type) => new Identity(type);
-  static Coercion error() => new CoercionError();
+class AssignmentCast extends DownCast {
+  AssignmentCast(TypeRules rules, Expression expression, Cast cast)
+      : super._internal(rules, expression, cast);
+
+  @override
+  String get name => 'STRONG_MODE_ASSIGNMENT_CAST';
+
+  toErrorCode() => new HintCode(name, message);
 }
 
 // Coercion which casts one type to another
 class Cast extends Coercion {
   Cast(DartType fromType, DartType toType) : super(fromType, toType);
 }
 
 // The identity coercion

[Leaf, 2015/12/04 19:01:11]

Comment out of place.

[pquitslund, 2015/12/04 19:13:33]

Done.

-class Identity extends Coercion {
-  Identity(DartType fromType) : super(fromType, fromType);
+abstract class Coercion {
+  final DartType fromType;
+  final DartType toType;
+  Coercion(this.fromType, this.toType);
+  static Coercion cast(DartType fromT, DartType toT) => new Cast(fromT, toT);
+  static Coercion error() => new CoercionError();
+  static Coercion identity(DartType type) => new Identity(type);
 }
 
 // The error coercion.  This coercion signals that a coercion
 // could not be generated.  The code generator should not see
 // these.
 class CoercionError extends Coercion {
   CoercionError() : super(null, null);
 }
 
 // TODO(jmesserly): this could use some refactoring. These are essentially
 // like ErrorCodes in analyzer, but we're including some details in our message.
 // Analyzer instead has template strings, and replaces '{0}' with the first
 // argument.

[Leaf, 2015/12/04 19:01:11]

ditto.

[pquitslund, 2015/12/04 19:13:33]

Done.

-abstract class StaticInfo {
-  /// AST Node this info is attached to.
-  AstNode get node;
-
-  // TODO(jmesserly): review the usage of error codes. We probably want our own,
-  // as well as some DDC specific [ErrorType]s.
-  ErrorCode toErrorCode();
-
-  // TODO(jmesserly): what convention to use here?
-  String get name => 'dev_compiler.$runtimeType';
-
-  List<Object> get arguments => [node];
-
-  AnalysisError toAnalysisError() {
-    int begin = node is AnnotatedNode
-        ? (node as AnnotatedNode).firstTokenAfterCommentAndMetadata.offset
-        : node.offset;
-    int length = node.end - begin;
-    var source = (node.root as CompilationUnit).element.source;
-    return new AnalysisError(source, begin, length, toErrorCode(), arguments);
-  }
-}
-
 /// Implicitly injected expression conversion.
 abstract class CoercionInfo extends StaticInfo {
+  static const String _propertyName = 'dev_compiler.src.info.CoercionInfo';
+
   final TypeRules rules;
 
   final Expression node;
 
-  DartType get convertedType;
-
   CoercionInfo(this.rules, this.node);
 
   DartType get baseType => rules.getStaticType(node);
+  DartType get convertedType;
+
+  String get message;
   DartType get staticType => convertedType;
 
-  String get message;
   toErrorCode() => new HintCode(name, message);
 
-  static const String _propertyName = 'dev_compiler.src.info.CoercionInfo';
-
   /// Gets the coercion info associated with this node.
   static CoercionInfo get(AstNode node) => node.getProperty(_propertyName);
 
   /// Sets the coercion info associated with this node.
   static CoercionInfo set(AstNode node, CoercionInfo info) {
     node.setProperty(_propertyName, info);
     return info;
   }
 }
 
-// Base class for all casts from base type to sub type.
 abstract class DownCast extends CoercionInfo {
   Cast _cast;
 
   DownCast._internal(TypeRules 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];
+
   Cast get cast => _cast;
 
   DartType get convertedType => _cast.toType;
-
-  @override List<Object> get arguments => [node, baseType, convertedType];
   @override String get message => '{0} ({1}) will need runtime check '
       'to cast to type {2}';
 
   // Factory to create correct DownCast variant.
   static StaticInfo create(TypeRules rules, Expression expression, Cast cast,
       {String reason}) {
     final fromT = cast.fromType;
     final toT = cast.toType;
 
     // toT <:_R fromT => to <: fromT
@@ skipping 57 matching lines @@
     var parent = expression.parent;
     if (parent is VariableDeclaration && (parent.initializer == expression)) {
       return new AssignmentCast(rules, expression, cast);
     }
 
     // Other casts
     return new DownCastImplicit(rules, expression, cast);
   }
 }
 
+// Base class for all casts from base type to sub type.

[Leaf, 2015/12/04 19:01:11]

I don't understand how this comment got here at all, but presumably an artifact
of the sorting somehow?

[pquitslund, 2015/12/04 19:13:33]

Done.

+class DownCastComposite extends DownCast {
+  DownCastComposite(TypeRules rules, Expression expression, Cast cast)
+      : super._internal(rules, expression, cast);
+
+  @override
+  String get name => 'STRONG_MODE_DOWN_CAST_COMPOSITE';
+
+  toErrorCode() => new StaticTypeWarningCode(name, message);
+}
+
 //
 // Standard down casts.  These casts are implicitly injected by the compiler.
 //
 
 // A down cast from dynamic to T.
-class DynamicCast extends DownCast {
-  DynamicCast(TypeRules rules, Expression expression, Cast cast)
+class DownCastImplicit extends DownCast {
+  DownCastImplicit(TypeRules rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
+  @override
+  String get name => 'STRONG_MODE_DOWN_CAST_IMPLICIT';
+
   toErrorCode() => new HintCode(name, message);
 }
 
 // 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(TypeRules rules, Expression expression, Cast cast)
+class DynamicCast extends DownCast {
+  DynamicCast(TypeRules rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
+  @override
+  String get name => 'STRONG_MODE_DYNAMIC_CAST';
+
   toErrorCode() => new HintCode(name, message);
 }
 
 //
 // 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(TypeRules rules, FunctionExpression expression, Cast cast)
-      : super._internal(rules, expression, cast);
+class DynamicInvoke extends CoercionInfo {
+  static const String _propertyName = 'dev_compiler.src.info.DynamicInvoke';
 
-  toErrorCode() => new StaticTypeWarningCode(name, message);
+  DynamicInvoke(TypeRules rules, Expression expression)
+      : super(rules, expression);
+  DartType get convertedType => rules.provider.dynamicType;
+  String get message => '{0} requires dynamic invoke';
+
+  @override
+  String get name => 'STRONG_MODE_DYNAMIC_INVOKE';
+
+  toErrorCode() => new HintCode(name, message);
+
+  /// Whether this [node] is the target of a dynamic operation.
+  static bool get(AstNode node) {
+    var value = node.getProperty(_propertyName);
+    return value != null ? value : false;
+  }
+
+  /// Sets whether this node is the target of a dynamic operation.
+  static bool set(AstNode node, bool value) {
+    // Free the storage for things that aren't dynamic.
+    if (value == false) value = null;
+    node.setProperty(_propertyName, value);
+    return value;
+  }
 }
 
 //
 // Implicit down casts.  These are only injected by the compiler by flag.
 //
 
 // A down cast to a non-ground type.  These behave differently from standard
 // Dart and may be more likely to fail at runtime.
-class DownCastComposite extends DownCast {
-  DownCastComposite(TypeRules rules, Expression expression, Cast cast)
-      : super._internal(rules, expression, cast);
-
-  toErrorCode() => new StaticTypeWarningCode(name, message);
+class Identity extends Coercion {
+  Identity(DartType fromType) : super(fromType, fromType);
 }
 
 // A down cast to a non-ground type.  These behave differently from standard
 // Dart and may be more likely to fail at runtime.
-class DownCastImplicit extends DownCast {
-  DownCastImplicit(TypeRules rules, Expression expression, Cast cast)
-      : super._internal(rules, expression, cast);
-
-  toErrorCode() => new HintCode(name, message);
-}
-
-// 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(TypeRules rules, Expression expression, this._type)
-      : super(rules, expression);
-
-  DartType get type => _type;
-  DartType get convertedType => type;
-  @override String get message => '{0} has inferred type {1}';
-  @override List get arguments => [node, type];
-
-  toErrorCode() => new HintCode(name, message);
-}
-
-// Standard / unspecialized inferred type
 class InferredType extends InferredTypeBase {
   InferredType(TypeRules rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
 
   // Factory to create correct InferredType variant.
+  @override
+  String get name => 'STRONG_MODE_INFERRED_TYPE';
+
   static InferredTypeBase create(
       TypeRules rules, Expression expression, DartType type) {
     // Specialized inference:
     if (expression is Literal) {
       return new InferredTypeLiteral(rules, expression, type);
     }
     if (expression is InstanceCreationExpression) {
       return new InferredTypeAllocation(rules, expression, type);
     }
     if (expression is FunctionExpression) {
       return new InferredTypeClosure(rules, expression, type);
     }
     return new InferredType(rules, expression, type);
   }
 }
 
-// An infered type for a literal expression.
-class InferredTypeLiteral extends InferredTypeBase {
-  InferredTypeLiteral(TypeRules rules, Expression expression, DartType type)
-      : super._internal(rules, expression, type);
-}
-
-// An inferred type for a non-literal allocation site.
+// An inferred type for the wrapped expression, which may need to be
+// reified into the term
 class InferredTypeAllocation extends InferredTypeBase {
   InferredTypeAllocation(TypeRules rules, Expression expression, DartType type)
       : super._internal(rules, expression, type);
+
+  @override
+  String get name => 'STRONG_MODE_INFERRED_TYPE_ALLOCATION';
 }
 
-// An inferred type for a closure expression
-class InferredTypeClosure extends InferredTypeBase {
-  InferredTypeClosure(TypeRules rules, Expression expression, DartType type)
-      : super._internal(rules, expression, type);
-}
+// Standard / unspecialized inferred type
+abstract class InferredTypeBase extends CoercionInfo {
+  final DartType _type;
 
-class DynamicInvoke extends CoercionInfo {
-  DynamicInvoke(TypeRules rules, Expression expression)
+  InferredTypeBase._internal(TypeRules rules, Expression expression, this._type)
       : super(rules, expression);
 
-  DartType get convertedType => rules.provider.dynamicType;
-  String get message => '{0} requires dynamic invoke';
-  toErrorCode() => new HintCode(name, message);
-
-  static const String _propertyName = 'dev_compiler.src.info.DynamicInvoke';
-
-  /// Whether this [node] is the target of a dynamic operation.
-  static bool get(AstNode node) {
-    var value = node.getProperty(_propertyName);
-    return value != null ? value : false;
-  }
-
-  /// Sets whether this node is the target of a dynamic operation.
-  static bool set(AstNode node, bool value) {
-    // Free the storage for things that aren't dynamic.
-    if (value == false) value = null;
-    node.setProperty(_propertyName, value);
-    return value;
-  }
-}
-
-abstract class StaticError extends StaticInfo {
-  final AstNode node;
-
-  StaticError(this.node);
-
-  String get message;
-
-  toErrorCode() => new CompileTimeErrorCode(name, message);
-}
-
-class StaticTypeError extends StaticError {
-  final DartType baseType;
-  final DartType expectedType;
-  String reason = null;
-
-  StaticTypeError(TypeRules rules, Expression expression, this.expectedType,
-      {this.reason})
-      : baseType = rules.getStaticType(expression),
-        super(expression);
-
-  @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');
-}
-
-class InvalidVariableDeclaration extends StaticError {
-  final DartType expectedType;
-
-  InvalidVariableDeclaration(
-      TypeRules 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}';
-}
-
-class InvalidParameterDeclaration extends StaticError {
-  final DartType expectedType;
-
-  InvalidParameterDeclaration(
-      TypeRules 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}';
-}
-
-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];
-  String get message =>
-      "Runtime check on non-ground type {0} may throw StrongModeError";
+  @override List get arguments => [node, type];
+  DartType get convertedType => type;
+  @override String get message => '{0} has inferred type {1}';
+  DartType get type => _type;
 
   toErrorCode() => new HintCode(name, message);
 }
 
-// Invalid override of an instance member of a class.
+// An inferred type for a literal expression.
+class InferredTypeClosure extends InferredTypeBase {
+  InferredTypeClosure(TypeRules rules, Expression expression, DartType type)
+      : super._internal(rules, expression, type);
+
+  @override
+  String get name => 'STRONG_MODE_INFERRED_TYPE_CLOSURE';
+}
+
+// An inferred type for a non-literal allocation site.
+class InferredTypeLiteral extends InferredTypeBase {
+  InferredTypeLiteral(TypeRules rules, Expression expression, DartType type)
+      : super._internal(rules, expression, type);
+
+  @override
+  String get name => 'STRONG_MODE_INFERRED_TYPE_LITERAL';
+}
+
+// An inferred type for a closure expression
+class InvalidFieldOverride extends InvalidOverride {
+  InvalidFieldOverride(AstNode node, ExecutableElement element,
+      InterfaceType base, DartType subType, DartType baseType)
+      : super(node, element, base, subType, baseType);
+
+  String get message => 'Field declaration {3}.{1} cannot be '
+      'overridden in {0}.';
+
+  @override
+  String get name => 'STRONG_MODE_INVALID_FIELD_OVERRIDE';
+}
+
+class InvalidMethodOverride extends InvalidOverride {
+  InvalidMethodOverride(AstNode node, ExecutableElement element,
+      InterfaceType base, FunctionType subType, FunctionType baseType)
+      : super(node, element, base, subType, baseType);
+
+  String get message => _messageHelper('Invalid override');
+
+  @override
+  String get name => 'STRONG_MODE_INVALID_METHOD_OVERRIDE';
+}
+
 abstract class InvalidOverride extends StaticError {
   /// Member declaration with the invalid override.
   final ExecutableElement element;
 
   /// Type (class or interface) that provides the base declaration.
   final InterfaceType base;
 
   /// Actual type of the overridden member.
   final DartType subType;
 
   /// Actual type of the base member.
   final DartType baseType;
 
   /// Whether the error comes from combining a base class and an interface
   final bool fromBaseClass;
 
   /// 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);
 
-  ClassElement get parent => element.enclosingElement;
-
   @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}).';
   }
 }
 
-// Invalid override due to incompatible type.  I.e., the overridden signature
-// is not compatible with the original.
-class InvalidMethodOverride extends InvalidOverride {
-  InvalidMethodOverride(AstNode node, ExecutableElement element,
-      InterfaceType base, FunctionType subType, FunctionType baseType)
-      : super(node, element, base, subType, baseType);
+class InvalidParameterDeclaration extends StaticError {
+  final DartType expectedType;
 
-  String get message => _messageHelper('Invalid override');
-}
+  InvalidParameterDeclaration(
+      TypeRules rules, FormalParameter declaration, this.expectedType)
+      : super(declaration);
 
-class InvalidFieldOverride extends InvalidOverride {
-  InvalidFieldOverride(AstNode node, ExecutableElement element,
-      InterfaceType base, DartType subType, DartType baseType)
-      : super(node, element, base, subType, baseType);
-
-  String get message => 'Field declaration {3}.{1} cannot be '
-      'overridden in {0}.';
+  @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 @@
 ///
 /// 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 "
       "list (see http://goo.gl/q1T4BB): {0}";
+
+  @override
+  String get name => 'STRONG_MODE_INVALID_SUPER_INVOCATION';
 }
+
+class InvalidVariableDeclaration extends StaticError {
+  final DartType expectedType;
+
+  InvalidVariableDeclaration(
+      TypeRules 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
+  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];
+  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);
+}
+
+// Invalid override of an instance member of a class.
+abstract class StaticError extends StaticInfo {
+  final AstNode node;
+
+  StaticError(this.node);
+
+  String get message;
+
+  toErrorCode() => new CompileTimeErrorCode(name, message);
+}
+
+// Invalid override due to incompatible type.  I.e., the overridden signature
+// is not compatible with the original.
+abstract class StaticInfo {
+  List<Object> get arguments => [node];
+
+  // TODO(jmesserly): review the usage of error codes. We probably want our own,
+  // as well as some DDC specific [ErrorType]s.
+  String get name;
+
+  /// AST Node this info is attached to.
+  AstNode get node;
+
+  AnalysisError toAnalysisError() {
+    int begin = node is AnnotatedNode
+        ? (node as AnnotatedNode).firstTokenAfterCommentAndMetadata.offset
+        : node.offset;
+    int length = node.end - begin;
+    var source = (node.root as CompilationUnit).element.source;
+    return new AnalysisError(source, begin, length, toErrorCode(), arguments);
+  }
+
+  ErrorCode toErrorCode();
+}
+
+class StaticTypeError extends StaticError {
+  final DartType baseType;
+  final DartType expectedType;
+  String reason = null;
+
+  StaticTypeError(TypeRules rules, Expression expression, this.expectedType,
+      {this.reason})
+      : baseType = rules.getStaticType(expression),
+        super(expression);
+
+  @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';
+}
+
+class UninferredClosure extends DownCast {
+  UninferredClosure(TypeRules rules, FunctionExpression expression, Cast cast)
+      : super._internal(rules, expression, cast);
+
+  @override
+  String get name => 'STRONG_MODE_UNINFERRED_CLOSURE';
+
+  toErrorCode() => new StaticTypeWarningCode(name, message);
+}