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;
+    if (!options.implicitCasts) {
+      errorCode = new CompileTimeErrorCode(name, _message);
+    } else if (downCastComposite) {
+      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 176 matching lines @@
     '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';
 }