More cleanup related to malformed and malbounded types.

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 10 matching lines @@
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
-DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
-DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
-DECLARE_FLAG(bool, error_on_malformed_type);
+DECLARE_FLAG(bool, error_on_bad_type);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
 static void CheckedModeHandler(bool value) {
   FLAG_enable_asserts = value;
   FLAG_enable_type_checks = value;
 }
 
 // --enable-checked-mode and --checked both enable checked mode which is
 // equivalent to setting --enable-asserts and --enable-type-checks.
 DEFINE_FLAG_HANDLER(CheckedModeHandler,
@@ skipping 6961 matching lines @@
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(FormatErrorWithAppend(
       prev_error, script_, token_pos, "Error", format, args));
   va_end(args);
   isolate()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 
-void Parser::Warning(intptr_t token_pos, const char* format, ...) {

[hausner, 2013/08/26 22:17:33]

Can you please leave Warning() and friends in the Parser? It comes in handy when
we make language changes and want to issue a message when we see deprecated
code.

[regis, 2013/08/26 23:23:38]

Done.

-  if (FLAG_silent_warnings) return;
-  va_list args;
-  va_start(args, format);
-  const Error& error = Error::Handle(
-      FormatError(script_, token_pos, "Warning", format, args));
-  va_end(args);
-  if (FLAG_warning_as_error) {
-    isolate()->long_jump_base()->Jump(1, error);
-    UNREACHABLE();
-  } else {
-    OS::Print("%s", error.ToErrorCString());
-  }
-}
-
-
-void Parser::Warning(const char* format, ...) {
-  if (FLAG_silent_warnings) return;
-  va_list args;
-  va_start(args, format);
-  const Error& error = Error::Handle(
-      FormatError(script_, TokenPos(), "Warning", format, args));
-  va_end(args);
-  if (FLAG_warning_as_error) {
-    isolate()->long_jump_base()->Jump(1, error);
-    UNREACHABLE();
-  } else {
-    OS::Print("%s", error.ToErrorCString());
-  }
-}
-
-
 void Parser::Unimplemented(const char* msg) {
   ErrorMsg(TokenPos(), "%s", msg);
 }
 
 
 void Parser::ExpectToken(Token::Kind token_expected) {
   if (CurrentToken() != token_expected) {
     ErrorMsg("'%s' expected", Token::Str(token_expected));
   }
   ConsumeToken();
@@ skipping 1219 matching lines @@
       if (!scope_class.IsNull()) {
         // First check if the type is a type parameter of the given scope class.
         const TypeParameter& type_parameter = TypeParameter::Handle(
             scope_class.LookupTypeParameter(unresolved_class_name));
         if (!type_parameter.IsNull()) {
           // A type parameter is considered to be a malformed type when
           // referenced by a static member.
           if (ParsingStaticMember()) {
             ASSERT(scope_class.raw() == current_class().raw());
             if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-                FLAG_error_on_malformed_type) {
+                FLAG_error_on_bad_type) {
               *type = ClassFinalizer::NewFinalizedMalformedType(
                   Error::Handle(),  // No previous error.
                   scope_class,
                   type->token_pos(),
                   "type parameter '%s' cannot be referenced "
                   "from static member",
                   String::Handle(type_parameter.name()).ToCString());
             } else {
               // Map the malformed type to dynamic and ignore type arguments.
               *type = Type::DynamicType();
             }
             return;
           }
           // A type parameter cannot be parameterized, so make the type
           // malformed if type arguments have previously been parsed.
           if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
             if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-                FLAG_error_on_malformed_type) {
+                FLAG_error_on_bad_type) {
               *type = ClassFinalizer::NewFinalizedMalformedType(
                   Error::Handle(),  // No previous error.
                   scope_class,
                   type_parameter.token_pos(),
                   "type parameter '%s' cannot be parameterized",
                   String::Handle(type_parameter.name()).ToCString());
             } else {
               // Map the malformed type to dynamic and ignore type arguments.
               *type = Type::DynamicType();
             }
             return;
           }
           *type = type_parameter.raw();
           return;
         }
       }
       // The referenced class may not have been parsed yet. It would be wrong
       // to resolve it too early to an imported class of the same name.
       if (finalization > ClassFinalizer::kResolveTypeParameters) {
         // Resolve classname in the scope of the current library.
         Error& error = Error::Handle();
         resolved_type_class = ResolveClassInCurrentLibraryScope(
             unresolved_class.token_pos(),
             unresolved_class_name,
             &error);
         if (!error.IsNull()) {
           if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-              FLAG_error_on_malformed_type) {
+              FLAG_error_on_bad_type) {
             *type = ClassFinalizer::NewFinalizedMalformedType(
                 error,
                 scope_class,
                 unresolved_class.token_pos(),
                 "cannot resolve class '%s'",
                 unresolved_class_name.ToCString());
           } else {
             // Map the malformed type to dynamic and ignore type arguments.
             *type = Type::DynamicType();
           }
           return;
         }
       }
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Resolve class name in the scope of the library prefix.
       Error& error = Error::Handle();
       resolved_type_class = ResolveClassInPrefixScope(
           unresolved_class.token_pos(),
           lib_prefix,
           unresolved_class_name,
           &error);
       if (!error.IsNull()) {
         if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-            FLAG_error_on_malformed_type) {
+            FLAG_error_on_bad_type) {
           *type = ClassFinalizer::NewFinalizedMalformedType(
               error,
               scope_class,
               unresolved_class.token_pos(),
               "cannot resolve class '%s'",
               unresolved_class_name.ToCString());
         } else {
           // Map the malformed type to dynamic and ignore type arguments.
           *type = Type::DynamicType();
         }
         return;
       }
     }
     // At this point, we can only have a parameterized_type.
     const Type& parameterized_type = Type::Cast(*type);
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
       if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-          FLAG_error_on_malformed_type) {
+          FLAG_error_on_bad_type) {
         ClassFinalizer::FinalizeMalformedType(
             Error::Handle(),  // No previous error.
             scope_class,
             parameterized_type,
             "type '%s' is not loaded",
             String::Handle(parameterized_type.UserVisibleName()).ToCString());
       } else {
         // Map the malformed type to dynamic and ignore type arguments.
         *type = Type::DynamicType();
       }
@@ skipping 780 matching lines @@
   AbstractTypeArguments& list_type_arguments =
       AbstractTypeArguments::ZoneHandle(type_arguments.raw());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using dynamic as the type argument for the element type.
   if (!list_type_arguments.IsNull()) {
     ASSERT(list_type_arguments.Length() > 0);
     // List literals take a single type argument.
     if (list_type_arguments.Length() == 1) {
       element_type = list_type_arguments.TypeAt(0);
     } else {
-      if (FLAG_error_on_malformed_type) {
+      if (FLAG_error_on_bad_type) {
         ErrorMsg(type_pos,
                  "a list literal takes one type argument specifying "
                  "the element type");
       }
       // Ignore type arguments.
       list_type_arguments = AbstractTypeArguments::null();
     }
     if (is_const && !element_type.IsInstantiated()) {
       ErrorMsg(type_pos,
                "the type argument of a constant list literal cannot include "
@@ skipping 177 matching lines @@
     // Map literals take two type arguments.
     if (map_type_arguments.Length() == 2) {
       key_type = map_type_arguments.TypeAt(0);
       value_type = map_type_arguments.TypeAt(1);
       if (is_const && !type_arguments.IsInstantiated()) {
         ErrorMsg(type_pos,
                  "the type arguments of a constant map literal cannot include "
                  "a type variable");
       }
       if (key_type.IsMalformed()) {
-        if (FLAG_error_on_malformed_type) {
+        if (FLAG_error_on_bad_type) {
           ErrorMsg(Error::Handle(key_type.malformed_error()));
         }
         // Map malformed key type to dynamic.
         key_type = Type::DynamicType();
         map_type_arguments.SetTypeAt(0, key_type);
       }
       if (value_type.IsMalformed()) {
-        if (FLAG_error_on_malformed_type) {
+        if (FLAG_error_on_bad_type) {
           ErrorMsg(Error::Handle(value_type.malformed_error()));
         }
         // Map malformed value type to dynamic.
         value_type = Type::DynamicType();
         map_type_arguments.SetTypeAt(1, value_type);
       }
     } else {
-      if (FLAG_error_on_malformed_type) {
+      if (FLAG_error_on_bad_type) {
         ErrorMsg(type_pos,
                  "a map literal takes two type arguments specifying "
                  "the key type and the value type");
       }
       // Ignore type arguments.
       map_type_arguments = AbstractTypeArguments::null();
     }
   }
   ASSERT((map_type_arguments.IsNull() &&
           key_type.IsDynamicType() && value_type.IsDynamicType()) ||
@@ skipping 213 matching lines @@
     if (type.IsTypeParameter() || type.IsDynamicType()) {
       // Replace the type with a malformed type.
       type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(),  // No previous error.
           current_class(),
           type_pos,
           "%s'%s' cannot be instantiated",
           type.IsTypeParameter() ? "type parameter " : "",
           type.IsTypeParameter() ?
               String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
-    } else if (FLAG_enable_type_checks || FLAG_error_on_malformed_type) {
+    } else if (FLAG_enable_type_checks || FLAG_error_on_bad_type) {
       Error& bound_error = Error::Handle();
       if (type.IsMalboundedWithError(&bound_error)) {
         // Replace the type with a malformed type.
         type = ClassFinalizer::NewFinalizedMalformedType(
             bound_error,
             current_class(),
             type_pos,
             "malbounded type '%s' cannot be instantiated",
             String::Handle(type.UserVisibleName()).ToCString());
       }
@@ skipping 781 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart