Throw a type error in production mode when the type of the type test is not

runtime/vm/parser.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 3148 matching lines @@
     Error* malformed_error,
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     const GrowableObjectArray& types =
         GrowableObjectArray::Handle(GrowableObjectArray::New());
     AbstractType& type = AbstractType::Handle();
     do {
       ConsumeToken();
       type = ParseType(finalization);
-      types.Add(type);
       // Only keep the error for the first malformed type argument.
       if (malformed_error->IsNull() && type.IsMalformed()) {
         *malformed_error = type.malformed_error();
       }
+      // Map a malformed type argument to Dynamic, so that malformed types with
+      // a resolved type class are handled properly in production mode.
+      if (type.IsMalformed()) {
+        type = Type::DynamicType();
+      }
+      types.Add(type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     if (finalization != ClassFinalizer::kIgnore) {
       return NewTypeArguments(types);
     }
@@ skipping 4026 matching lines @@
   }
   Error& malformed_error = Error::Handle();
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(ParseTypeArguments(&malformed_error,
                                                        finalization));
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
       Type::New(type_class, type_arguments, type_name.ident_pos));
-  if (!malformed_error.IsNull()) {
+  // In production mode, malformed type arguments are mapped to Dynamic.
+  // In checked mode, a type with malformed type arguments is malformed.
+  if (FLAG_enable_type_checks && !malformed_error.IsNull()) {
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
     parameterized_type.set_arguments(AbstractTypeArguments::Handle());
     parameterized_type.set_malformed_error(malformed_error);
   }
   if (finalization >= ClassFinalizer::kTryResolve) {
     const Class& scope_class = Class::Handle(TypeParametersScopeClass());
     ResolveTypeFromClass(scope_class, finalization, &type);
     if (finalization >= ClassFinalizer::kFinalize) {
@@ skipping 1173 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart