Skip qualified identifiers that are part of ignored 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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 804 matching lines @@
     }
     // We have not seen a parameter type yet, so we check if the next
     // identifier could represent a type before parsing it.
     Token::Kind follower = LookaheadToken(1);
     // We have an identifier followed by a 'follower' token.
     // We either parse a type or assume that no type is specified.
     if ((follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         Token::IsIdentifier(follower) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
+      // The types of formal parameters are never ignored, even in unchecked
+      // mode, because they are part of the function type of closurized
+      // functions appearing in type tests with typedefs.
       parameter.type = &AbstractType::ZoneHandle(
           ParseType(is_top_level_ ? kCanResolve : kMustResolve));
     } else {
       parameter.type = &Type::ZoneHandle(Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
@@ skipping 1487 matching lines @@
       // We have an identifier followed by a 'follower' token.
       // We either parse a type or assume that no type is specified.
       if ((follower == Token::kLT) ||  // Parameterized type.
           (follower == Token::kGET) ||  // Getter following a type.
           (follower == Token::kSET) ||  // Setter following a type.
           (follower == Token::kOPERATOR) ||  // Operator following a type.
           (Token::IsIdentifier(follower))  ||  // Member name following a type.
           ((follower == Token::kPERIOD) &&    // Qualified class name of type,
            (LookaheadToken(3) != Token::kLPAREN))) {  // but not a named constr.
         ASSERT(is_top_level_);
+        // The declared type of fields is never ignored, even in unchecked mode,
+        // because getters and setters could be closurized at some time (not
+        // supported yet).
         member.type = &AbstractType::ZoneHandle(ParseType(kCanResolve));
       }
     }
   }
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name = CurrentLiteral();
     member.name_pos = this->token_index_;
     ConsumeToken();
@@ skipping 314 matching lines @@
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   const intptr_t result_type_pos = token_index_;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
-    result_type = ParseType(kDoNotResolve);  // No owner class yet.
+    // Type annotations in typedef are never ignored, even in unchecked mode.
+    // Wait until we have an owner class before resolving the result type.
+    result_type = ParseType(kDoNotResolve);
   }
 
   const intptr_t alias_name_pos = token_index_;
   const String* alias_name =
       ExpectTypeIdentifier("function alias name expected");
 
   // Allocate an interface to hold the type parameters and their 'extends'
   // constraints. Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(String::NewSymbol(":alias_owner")),
@@ skipping 3972 matching lines @@
 // Parses type = [ident "."] ident ["<" type { "," type } ">"].
 // Returns the class object if the type can be resolved. Otherwise, either give
 // an error if type resolution was required, or return the unresolved name as a
 // string object.
 RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   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());
+  if (type_resolution == kIgnore) {
+    SkipQualIdent();
+  } else {
+    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 == 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();
     }
@@ skipping 1084 matching lines @@
   }
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
+
+void Parser::SkipQualIdent() {
+  ASSERT(IsIdentifier());
+  ConsumeToken();
+  if (CurrentToken() == Token::kPERIOD) {
+    ConsumeToken();  // Consume the kPERIOD token.
+    ExpectIdentifier("identifier expected after '.'");
+  }
+}
+
 }  // namespace dart