Version 0.8.10.4

dart/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 4821 matching lines @@
     library_.ReplaceObject(func, accessor_name);
   }
   if (metadata_pos >= 0) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
 
 
 RawObject* Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
-                                          intptr_t token_pos,
-                                          const String& url) {
+                                         intptr_t token_pos,
+                                         const String& url) {
   Dart_LibraryTagHandler handler = isolate()->library_tag_handler();
   if (handler == NULL) {
     if (url.StartsWith(Symbols::DartScheme())) {
       if (tag == Dart_kCanonicalizeUrl) {
         return url.raw();
       }
       return Object::null();
     }
     ErrorMsg(token_pos, "no library handler registered");
   }
@@ skipping 547 matching lines @@
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
                                           bool is_const) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
   const intptr_t ident_pos = TokenPos();
-  LocalVariable* variable =
-      new LocalVariable(ident_pos, *CurrentLiteral(), type);
-  ASSERT(current_block_ != NULL);
-  ASSERT(current_block_->scope != NULL);
+  const String& ident = *CurrentLiteral();
+  LocalVariable* variable = new LocalVariable(ident_pos, ident, type);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
     AstNode* expr = ParseExpr(is_const, kConsumeCascades);
     initialization = new StoreLocalNode(assign_pos, variable, expr);
     if (is_const) {
       ASSERT(expr->IsLiteralNode());
       variable->SetConstValue(expr->AsLiteralNode()->literal());
     }
   } else if (is_final || is_const) {
     ErrorMsg(ident_pos,
     "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
     AstNode* null_expr = new LiteralNode(ident_pos, Instance::ZoneHandle());
     initialization = new StoreLocalNode(ident_pos, variable, null_expr);
   }
+
+  ASSERT(current_block_ != NULL);
+  const intptr_t previous_pos =
+  current_block_->scope->PreviousReferencePos(ident);
+  if (previous_pos >= 0) {
+    ASSERT(!script_.IsNull());
+    if (previous_pos > ident_pos) {
+      ErrorMsg(ident_pos,
+               "initializer of '%s' may not refer to itself",
+               ident.ToCString());
+
+    } else {
+      intptr_t line_number;
+      script_.GetTokenLocation(previous_pos, &line_number, NULL);
+      ErrorMsg(ident_pos,
+               "identifier '%s' previously used in line %" Pd "",
+               ident.ToCString(),
+               line_number);
+    }
+  }
+
   // Add variable to scope after parsing the initalizer expression.
   // The expression must not be able to refer to the variable.
   if (!current_block_->scope->AddVariable(variable)) {
     LocalVariable* existing_var =
         current_block_->scope->LookupVariable(variable->name(), true);
     ASSERT(existing_var != NULL);
     if (existing_var->owner() == current_block_->scope) {
       ErrorMsg(ident_pos, "identifier '%s' already defined",
                variable->name().ToCString());
     } else {
@@ skipping 94 matching lines @@
     ASSERT(CurrentToken() == Token::kLPAREN);
     function_name = &Symbols::AnonymousClosure();
   } else {
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
       result_type = Type::VoidType();
     } else if ((CurrentToken() == Token::kIDENT) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(ClassFinalizer::kCanonicalize);
     }
+    const intptr_t name_pos = TokenPos();
     variable_name = ExpectIdentifier("function name expected");
     function_name = variable_name;
+
+    // Check that the function name has not been referenced
+    // before this declaration.
+    ASSERT(current_block_ != NULL);
+    const intptr_t previous_pos =
+        current_block_->scope->PreviousReferencePos(*function_name);
+    if (previous_pos >= 0) {
+      ASSERT(!script_.IsNull());
+      intptr_t line_number;
+      script_.GetTokenLocation(previous_pos, &line_number, NULL);
+      ErrorMsg(name_pos,
+               "identifier '%s' previously used in line %" Pd "",
+               function_name->ToCString(),
+               line_number);
+    }
   }
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
 
   // Check whether we have parsed this closure function before, in a previous
   // compilation. If so, reuse the function object, else create a new one
   // and register it in the current class.
   // Note that we cannot share the same closure function between the closurized
@@ skipping 3350 matching lines @@
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
                                       const String &ident,
                                       AstNode** node) {
   TRACE_PARSER("ResolveIdentInLocalScope");
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
+  if (current_block_ != NULL) {
+    current_block_->scope->AddReferencedName(ident_pos, ident);
+  }
   if (local != NULL) {
     if (node != NULL) {
       if (local->IsConst()) {
         *node = new LiteralNode(ident_pos, *local->ConstValue());
       } else {
         *node = new LoadLocalNode(ident_pos, local);
       }
     }
     return true;
   }
@@ skipping 324 matching lines @@
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseType");
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   if (finalization == ClassFinalizer::kIgnore) {
+    if (!is_top_level_ && (current_block_ != NULL)) {
+      // Add the library prefix or type class name to the list of referenced
+      // names of this scope, even if the type is ignored.
+      current_block_->scope->AddReferencedName(TokenPos(), *CurrentLiteral());
+    }
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
         (type_name.lib_prefix == NULL) &&
         ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) {
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
       if (finalization == ClassFinalizer::kCanonicalizeWellFormed) {
@@ skipping 1461 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart