Ignore parsed types of local variables in unchecked mode and replace them with

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 2955 matching lines @@
       ConsumeToken();
       AbstractType& type = AbstractType::ZoneHandle(ParseType(type_resolution));
       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");
     }
-    return NewTypeArguments(types);
+    if (type_resolution != kIgnore) {
+      return NewTypeArguments(types);
+    }
   }
   return TypeArguments::null();
 }
 
 
 // Parse and return an array of interface types.
 RawArray* Parser::ParseInterfaceList() {
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
   GrowableArray<AbstractType*> interfaces;
@@ skipping 46 matching lines @@
     }
   }
   cls_interfaces = NewArray<AbstractType>(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
-  const AbstractType& type = AbstractType::ZoneHandle(
-      ParseFinalVarOrType(kIsMandatory, kCanResolve));
+  const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
+      FLAG_enable_type_checks ? kCanResolve : kIgnore));
 
   while (true) {
     const intptr_t name_pos = token_index_;
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
     if (library_.LookupObject(accessor_name) != Object::null()) {
@@ skipping 595 matching lines @@
   }
   if (is_final) {
     variable->set_is_final();
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | type).
 // The presence of 'final' must be detected and remembered before the call.
-// If type_specification is kIsOptional, and no type can be parsed, then return
-// the DynamicType.
 // If a type is parsed, it is resolved (or not) according to type_resolution.
-RawAbstractType* Parser::ParseFinalVarOrType(
-    TypeSpecification type_specification, TypeResolution type_resolution) {
+RawAbstractType* Parser::ParseFinalVarOrType(TypeResolution type_resolution) {
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
+  bool type_is_optional = false;
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
-    type_specification = kIsOptional;
+    type_is_optional = true;
   }
   if (CurrentToken() != Token::kIDENT) {
-    if (type_specification == kIsOptional) {
+    if (type_is_optional) {
       return Type::DynamicType();
     } else {
       ErrorMsg("type name expected");
     }
   }
-  if (type_specification == kIsOptional) {
+  if (type_is_optional) {
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or return now.
     if ((follower != Token::kLT) &&  // Parameterized type.
         (follower != Token::kPERIOD) &&  // Qualified class name of type.
         !Token::IsIdentifier(follower) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {  // Field parameter following a type.
       return Type::DynamicType();
     }
   }
   return ParseType(type_resolution);
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   bool is_final = (CurrentToken() == Token::kFINAL);
-  const AbstractType& type = AbstractType::ZoneHandle(
-      ParseFinalVarOrType(kIsMandatory, kMustResolve));
+  const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
+      FLAG_enable_type_checks ? kMustResolve : kIgnore));
   if (!IsIdentifier()) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final);
   ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (!IsIdentifier()) {
       ErrorMsg("identifier expected after comma");
@@ skipping 671 matching lines @@
                                      SourceLabel* label) {
   bool is_final = (CurrentToken() == Token::kFINAL);
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = token_index_;
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
-    const AbstractType& type = AbstractType::ZoneHandle(
-        ParseFinalVarOrType(kIsMandatory, kMustResolve));
+    const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
+        FLAG_enable_type_checks ? kMustResolve : kIgnore));
     loop_var_pos = token_index_;
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = token_index_;
   AstNode* collection_expr = ParseExpr(kAllowConst);
@@ skipping 240 matching lines @@
   bool is_final;
 };
 
 
 // Parse the parameter specified in the catch clause.
 void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
   TRACE_PARSER("ParseCatchParameter");
   ASSERT(catch_param != NULL);
   catch_param->is_final = (CurrentToken() == Token::kFINAL);
   catch_param->type = &AbstractType::ZoneHandle(
-      ParseFinalVarOrType(kIsMandatory, kMustResolve));
+      ParseFinalVarOrType(kMustResolve));

[hausner, 2012/01/18 17:50:57]

We may want to check with Gilad to make sure this type must resolve. I'd
definitely say it has to, but one never knows...

[regis, 2012/01/18 18:09:18]

I have added a comment stating that the type must always be resolved, even in
unchecked mode. This is consistent with the spec.

   catch_param->token_index = token_index_;
   catch_param->var = ExpectIdentifier("identifier expected");
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(const CatchParamDesc& exception_param,
                                    const CatchParamDesc& stack_trace_param,
                                    LocalScope* scope) {
   ASSERT(exception_param.var != NULL);
@@ skipping 1984 matching lines @@
   }
   QualIdent type_name;
   const intptr_t type_pos = token_index_;
   ParseQualIdent(&type_name);
   if (type_name.is_local_scope_ident) {
     ErrorMsg(type_pos, "using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
   Class& scope_class = Class::Handle();
   Object& type_class = Object::Handle();
-  if (type_resolution == kDoNotResolve) {
+  if (type_resolution == kIgnore) {
+    // Leave type_class as null.
+  } else if (type_resolution == kDoNotResolve) {
     String& qualifier = String::Handle();
     if (type_name.qualifier != NULL) {
       qualifier ^= type_name.qualifier->raw();
     }
     type_class = UnresolvedClass::New(type_pos, qualifier, *(type_name.ident));
   } else {
     scope_class = TypeParametersScopeClass();
     if (!scope_class.IsNull()) {
       TypeParameter& type_parameter = TypeParameter::Handle();
       // Check if qualifier is a type parameter in scope.
@@ skipping 24 matching lines @@
           }
           return type_parameter.raw();
         }
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(ParseTypeArguments(type_resolution));
+  if (type_resolution == kIgnore) {
+    return Type::DynamicType();
+  }
   Type& type = Type::Handle(
       Type::NewParameterizedType(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
     ASSERT(type_class.IsClass());  // Must be resolved.
     Error& error = Error::Handle();
     type ^= ClassFinalizer::FinalizeAndCanonicalizeType(scope_class,
                                                         type,
                                                         &error);
     if (!error.IsNull()) {
       ErrorMsg(error.ToErrorCString());
@@ skipping 1027 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart