Remove redundant verbiage on inference failure errors.

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;
 
@@ skipping 89 matching lines @@
 
   Cast get cast => _cast;
 
   DartType get convertedType => _cast.toType;
 
   @override
   String get message => 'Unsound implicit cast from {0} to {1}';
 
   // Factory to create correct DownCast variant.
   static StaticInfo create(
-      StrongTypeSystemImpl rules, Expression expression, Cast cast,
-      {String reason}) {
+      StrongTypeSystemImpl rules, Expression expression, Cast cast) {
     final fromT = cast.fromType;
     final toT = cast.toType;
 
     // 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(toT.isSubtypeOf(fromT) || fromT.isAssignableTo(toT));
 
     // Handle null call specially.
     if (expression is NullLiteral) {
       // TODO(vsm): Create a NullCast for this once we revisit nonnullability.
       return new DownCastImplicit(rules, expression, cast);
     }
 
     // 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, toT, reason: reason);
+      return new StaticTypeError(rules, expression, toT);
     }
+
     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, toT, reason: reason);
+        return new StaticTypeError(rules, expression, toT);
       }
     }
 
     Element element = null;
     if (expression is PropertyAccess) {
       element = expression.propertyName.staticElement;
     } else if (expression is Identifier) {
       element = expression.staticElement;
     }
     // First class functions and static methods, where we know the original
     // declaration, will have an exact type, so we know a downcast will fail.
     if (element is FunctionElement ||
         element is MethodElement && element.isStatic) {
-      return new StaticTypeError(rules, expression, toT, reason: reason);
+      return new StaticTypeError(rules, expression, toT);
     }
 
     // TODO(vsm): Change this to an assert when we have generic methods and
     // fix TypeRules._coerceTo to disallow implicit sideways casts.
     if (!rules.isSubtypeOf(toT, fromT)) {
       assert(toT.isSubtypeOf(fromT) || fromT.isAssignableTo(toT));
       return new DownCastComposite(rules, expression, cast);
     }
 
     // Composite cast: these are more likely to fail.
@@ skipping 387 matching lines @@
   }
 
   // TODO(jmesserly): review the usage of error codes. We probably want our own,
   // as well as some DDC specific [ErrorType]s.
   ErrorCode toErrorCode();
 }
 
 class StaticTypeError extends StaticError {
   final DartType baseType;
   final DartType expectedType;
-  String reason = null;
 
-  StaticTypeError(TypeSystem rules, Expression expression, this.expectedType,
-      {this.reason})
+  StaticTypeError(TypeSystem rules, 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}' +
-      ((reason == null) ? '' : ' because $reason');
+  String get message => 'Type check failed: {0} ({1}) is not of type {2}';
 
   @override
   String get name => 'STRONG_MODE_STATIC_TYPE_ERROR';
 }