Add analysis option that will be used to fix #26583

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/error.dart';
+import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/type_system.dart';
 
-/// A down cast due to a variable declaration to a ground type:
-///
-///     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, DartType fromType,
-      DartType toType)
-      : super._internal(rules, expression, fromType, toType);
-
-  @override
-  String get name => 'STRONG_MODE_ASSIGNMENT_CAST';
-
-  toErrorCode() => new HintCode(name, message);
-}
-
 /// Implicitly injected expression conversion.
 abstract class CoercionInfo extends StaticInfo {
   static const String _propertyName = 'dev_compiler.src.info.CoercionInfo';
 
-  final TypeSystem rules;
-
   final Expression node;
 
-  CoercionInfo(this.rules, this.node);
+  CoercionInfo(this.node);
 
   DartType get baseType => node.staticType ?? DynamicTypeImpl.instance;
   DartType get convertedType;
 
   String get message;
   DartType get staticType => convertedType;
 
   toErrorCode() => new HintCode(name, message);
 
   /// 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 {
+/// Implicit casts from base type to sub type.
+class DownCast extends CoercionInfo {
   final DartType _fromType;
   final DartType _toType;
+  ErrorCode _errorCode;
 
-  DownCast._internal(
-      TypeSystem rules, Expression expression, this._fromType, this._toType)
-      : super(rules, expression);
+  DownCast._(
+      Expression expression, this._fromType, this._toType, this._errorCode)
+      : super(expression);
 
   @override
   List<Object> get arguments => [baseType, convertedType];
 
   /// The type being cast from.
   ///
   /// This is usually the static type of the associated expression, but may not
   /// be if the cast is attached to a variable in a for-in loop.
   @override
   DartType get baseType => _fromType;
 
+  @override
   DartType get convertedType => _toType;
 
   @override
-  String get message => 'Unsound implicit cast from {0} to {1}';
+  String get message => _message;
+
+  @override
+  String get name => _errorCode.name;
+
+  @override
+  toErrorCode() => _errorCode;
+
+  static const String _message = 'Unsound implicit cast from {0} to {1}';
 
   /// Factory to create correct DownCast variant.
   static StaticInfo create(StrongTypeSystemImpl rules, Expression expression,
-      DartType fromType, DartType toType) {
+      DartType fromType, DartType toType, AnalysisOptionsImpl options) {
     // toT <:_R fromT => to <: fromT
     // NB: classes with call methods are subtypes of function
     // types, but the function type is not assignable to the class
     assert(toType.isSubtypeOf(fromType) || fromType.isAssignableTo(toType));
 
     // Inference "casts":
     if (expression is Literal || expression is FunctionExpression) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
-      return new StaticTypeError(rules, expression, toType);
+      return new StaticTypeError(expression, toType);
     }
 
     if (expression is InstanceCreationExpression) {
       ConstructorElement e = expression.staticElement;
       if (e == null || !e.isFactory) {
         // fromT should be an exact type - this will almost certainly fail at
         // runtime.
-        return new StaticTypeError(rules, expression, toType);
+        return new StaticTypeError(expression, toType);
       }
     }
 
     if (StaticInfo.isKnownFunction(expression)) {
-      return new StaticTypeError(rules, expression, toType);
+      return new StaticTypeError(expression, toType);
     }
 
     // TODO(vsm): Change this to an assert when we have generic methods and
     // fix TypeRules._coerceTo to disallow implicit sideways casts.
+    bool downCastComposite = false;
     if (!rules.isSubtypeOf(toType, fromType)) {
       assert(toType.isSubtypeOf(fromType) || fromType.isAssignableTo(toType));
-      return new DownCastComposite(rules, expression, fromType, toType);
+      downCastComposite = true;
     }
 
     // Composite cast: these are more likely to fail.
     if (!rules.isGroundType(toType)) {
       // This cast is (probably) due to our different treatment of dynamic.
       // It may be more likely to fail at runtime.
       if (fromType is InterfaceType) {
         // For class types, we'd like to allow non-generic down casts, e.g.,
         // Iterable<T> to List<T>.  The intuition here is that raw (generic)
         // casts are problematic, and we should complain about those.
         var typeArgs = fromType.typeArguments;
-        if (typeArgs.isEmpty || typeArgs.any((t) => t.isDynamic)) {
-          return new DownCastComposite(rules, expression, fromType, toType);
-        }
+        downCastComposite =
+            typeArgs.isEmpty || typeArgs.any((t) => t.isDynamic);
       } else {
-        return new DownCastComposite(rules, expression, fromType, toType);
+        downCastComposite = true;
       }
     }
 
-    // Dynamic cast
-    if (fromType.isDynamic) {
-      return new DynamicCast(rules, expression, fromType, toType);
+    var parent = expression.parent;
+    String name;
+    if (downCastComposite) {
+      name = 'STRONG_MODE_DOWN_CAST_COMPOSITE';
+    } else if (fromType.isDynamic) {
+      name = 'STRONG_MODE_DYNAMIC_CAST';
+    } else if (parent is VariableDeclaration &&
+        parent.initializer == expression) {
+      name = 'STRONG_MODE_ASSIGNMENT_CAST';
+    } else {
+      name = 'STRONG_MODE_DOWN_CAST_IMPLICIT';
     }
 
-    // Assignment cast
-    var parent = expression.parent;
-    if (parent is VariableDeclaration && (parent.initializer == expression)) {
-      return new AssignmentCast(rules, expression, fromType, toType);
+    // For the remaining cases, we allow implicit casts by default.
+    // However this can be disabled with an option.
+    ErrorCode errorCode;

[Brian Wilkerson, 2016/06/08 18:31:35]

Creating a new ErrorCode for each error is really weird. I suppose it works, but
I'd like to change this code later to work the way the rest of the framework
works (or understand why it can't if that's the case).

[Jennifer Messerly, 2016/06/08 19:01:52]

You're 100% right! It is super weird. I can't think of any reason for it. I
think it dates back to before this code was integrated into Analyzer. That's the
only thing I can think of.

I can take a stab at cleaning it up. I actually have a branch that moves
implicit cast over into StaticWarningCode/HintCode in the normal way ... but in
that branch I also got rid of all the different classifications (they all have
the same error message string) and it wasn't clear to me if the distinctions
actually mattered or not. I guess I could create a suite of ErrorCodes with the
same messages.

[Brian Wilkerson, 2016/06/08 19:06:07]

Having multiple error codes would be useful if (a) we think we might want to
differentiate the error (or correction) messages to improve the UX or (b) we
think users might want to ignore / disable errors in some cases but not others.

Cleaning it up would be great, but it might not be our top priority at the
moment.

+    if (downCastComposite || !options.implicitCasts) {
+      errorCode = new StaticWarningCode(name, _message);
+    } else {
+      errorCode = new HintCode(name, _message);
     }
-
-    // Other casts
-    return new DownCastImplicit(rules, expression, fromType, toType);
+    return new DownCast._(expression, fromType, toType, errorCode);
   }
 }
 
-/// 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(TypeSystem rules, Expression expression, DartType fromType,
-      DartType toType)
-      : super._internal(rules, expression, fromType, toType);
-
-  @override
-  String get name => 'STRONG_MODE_DOWN_CAST_COMPOSITE';
-
-  toErrorCode() => new StaticWarningCode(name, message);
-}
-
-/// 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(TypeSystem rules, Expression expression, DartType fromType,
-      DartType toType)
-      : super._internal(rules, expression, fromType, toType);
-
-  @override
-  String get name => 'STRONG_MODE_DOWN_CAST_IMPLICIT';
-
-  toErrorCode() => new HintCode(name, message);
-}
-
-/// A down cast from dynamic to T.
-class DynamicCast extends DownCast {
-  DynamicCast(TypeSystem rules, Expression expression, DartType fromType,
-      DartType toType)
-      : super._internal(rules, expression, fromType, toType);
-
-  @override
-  String get name => 'STRONG_MODE_DYNAMIC_CAST';
-
-  toErrorCode() => new HintCode(name, message);
-}
-
 class DynamicInvoke extends CoercionInfo {
   static const String _propertyName = 'dev_compiler.src.info.DynamicInvoke';
 
-  DynamicInvoke(TypeSystem rules, Expression expression)
-      : super(rules, expression);
+  DynamicInvoke(Expression expression) : super(expression);
   DartType get convertedType => DynamicTypeImpl.instance;
   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) => node.getProperty(_propertyName) ?? 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;
   }
 }
 
-/// Standard / unspecialized inferred type.
-class InferredType extends InferredTypeBase {
-  InferredType(TypeSystem rules, Expression expression, DartType type)
-      : super._internal(rules, expression, type);
+/// A marker for an inferred type.
+class InferredType extends CoercionInfo {
+  @override
+  final String name;
 
-  @override
-  String get name => 'STRONG_MODE_INFERRED_TYPE';
+  final DartType type;
+
+  InferredType(Expression expression, this.type, this.name) : super(expression);
 
   /// Factory to create correct InferredType variant.
-  static InferredTypeBase create(
+  static InferredType create(
       TypeSystem rules, Expression expression, DartType type) {
     // Specialized inference:
+    String name;
     if (expression is Literal) {
-      return new InferredTypeLiteral(rules, expression, type);
+      name = 'STRONG_MODE_INFERRED_TYPE_LITERAL';
+    } else if (expression is InstanceCreationExpression) {
+      name = 'STRONG_MODE_INFERRED_TYPE_ALLOCATION';
+    } else if (expression is FunctionExpression) {
+      name = 'STRONG_MODE_INFERRED_TYPE_CLOSURE';
+    } else {
+      name = 'STRONG_MODE_INFERRED_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);
+    return new InferredType(expression, type, name);
   }
-}
-
-/// An inferred type for a non-literal allocation site.
-class InferredTypeAllocation extends InferredTypeBase {
-  InferredTypeAllocation(TypeSystem rules, Expression expression, DartType type)
-      : super._internal(rules, expression, type);
-
-  @override
-  String get name => 'STRONG_MODE_INFERRED_TYPE_ALLOCATION';
-}
-
-/// 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];
+
   DartType get convertedType => type;
+
   @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);
-
-  @override
-  String get name => 'STRONG_MODE_INFERRED_TYPE_CLOSURE';
-}
-
-/// An inferred type for a literal expression.
-class InferredTypeLiteral extends InferredTypeBase {
-  InferredTypeLiteral(TypeSystem rules, Expression expression, DartType type)
-      : super._internal(rules, expression, type);
-
-  @override
-  String get name => 'STRONG_MODE_INFERRED_TYPE_LITERAL';
-}
-
 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';
@@ skipping 160 matching lines @@
 // Analyzer instead has template strings, and replaces '{0}' with the first
 // argument.
 abstract class StaticInfo {
   /// Strong-mode error code names.
   ///
   /// Used for error code configuration validation in an analysis options file.
   static const List<String> names = const [
     //
     // Manually populated.
     //
     'STRONG_MODE_ASSIGNMENT_CAST',

[Jennifer Messerly, 2016/06/08 17:50:47]

do we need all of these? I started to consolidate them but then backed off, I'm
not sure if anyone is using these to filter errors or not.

ASSIGNMENT_CAST in particular seems like it should be folded into
DOWN_CAST_IMPLICIT. We also discussed (in the github issue) folding in
DYNAMIC_CAST.

     'STRONG_MODE_DOWN_CAST_COMPOSITE',
     'STRONG_MODE_DOWN_CAST_IMPLICIT',
     'STRONG_MODE_DYNAMIC_CAST',
     'STRONG_MODE_DYNAMIC_INVOKE',
     'STRONG_MODE_INFERRED_TYPE',
     'STRONG_MODE_INFERRED_TYPE_ALLOCATION',
     'STRONG_MODE_INFERRED_TYPE_CLOSURE',
     'STRONG_MODE_INFERRED_TYPE_LITERAL',
     'STRONG_MODE_INVALID_FIELD_OVERRIDE',
     'STRONG_MODE_INVALID_METHOD_OVERRIDE',
     'STRONG_MODE_INVALID_PARAMETER_DECLARATION',
     'STRONG_MODE_INVALID_SUPER_INVOCATION',
     'STRONG_MODE_INVALID_VARIABLE_DECLARATION',
     'STRONG_MODE_NON_GROUND_TYPE_CHECK_INFO',
     'STRONG_MODE_STATIC_TYPE_ERROR',
-    'STRONG_MODE_UNINFERRED_CLOSURE',
   ];
 
   List<Object> get arguments => [node];
 
   String get name;
 
   /// AST Node this info is attached to.
   AstNode get node;
 
   AnalysisError toAnalysisError() {
@@ skipping 22 matching lines @@
     // declaration, will have an exact type, so we know a downcast will fail.
     return element is FunctionElement ||
         element is MethodElement && element.isStatic;
   }
 }
 
 class StaticTypeError extends StaticError {
   final DartType baseType;
   final DartType expectedType;
 
-  StaticTypeError(TypeSystem rules, Expression expression, this.expectedType)
+  StaticTypeError(Expression expression, this.expectedType)
       : baseType = expression.staticType ?? DynamicTypeImpl.instance,
         super(expression);
 
   @override
   List<Object> get arguments => [node, baseType, expectedType];
   @override
   String get message => 'Type check failed: {0} ({1}) is not of type {2}';
 
   @override
   String get name => 'STRONG_MODE_STATIC_TYPE_ERROR';
 }