Repeated prefixes and parser fixes.

dart/frog/leg/elements/elements.dart

 // 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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 74 matching lines @@
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Modifiers get modifiers() => null;
 
   Node parseNode(DiagnosticListener listener) {
-    listener.cancel("Internal Error: Element.parseNode");
+    listener.cancel("Internal Error: $this.parseNode", token: position());
   }
 
   Type computeType(Compiler compiler) {
-    compiler.internalError("Element.computeType.");
+    compiler.internalError("$this.computeType.", token: position());
   }
 
   bool isFunction() => kind === ElementKind.FUNCTION;
   bool isMember() =>
       enclosingElement !== null && enclosingElement.kind === ElementKind.CLASS;
   bool isInstanceMember() => false;
   bool isFactoryConstructor() => modifiers !== null && modifiers.isFactory();
   bool isGenerativeConstructor() => kind === ElementKind.GENERATIVE_CONSTRUCTOR;
   bool isCompilationUnit() {
     return kind === ElementKind.COMPILATION_UNIT ||
            kind === ElementKind.LIBRARY;
   }
   bool isClass() => kind === ElementKind.CLASS;
   bool isVariable() => kind === ElementKind.VARIABLE;
   bool isParameter() => kind === ElementKind.PARAMETER;
   bool isStatement() => kind === ElementKind.STATEMENT;
   bool isTypedef() => kind === ElementKind.TYPEDEF;
   bool isGetter() => kind === ElementKind.GETTER;
   bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinal()) return false;
     if (isFunction() || isGenerativeConstructor()) return false;
     return true;
   }
 
   Token position() => null;
 
+  Token findMyName(Token token) {
+    for (Token t = token; t !== EOF_TOKEN; t = t.next) {
+      if (t.value == name) return t;
+    }
+    return token;
+  }
+
   const Element(this.name, this.kind, this.enclosingElement);
 
   // TODO(kasperl): This is a very bad hash code for the element and
   // there's no reason why two elements with the same name should have
   // the same hash code. Replace this with a simple id in the element?
   int hashCode() => name.hashCode();
 
   CompilationUnitElement getCompilationUnit() {
     Element element = this;
     while (element !== null && !element.isCompilationUnit()) {
@@ skipping 125 matching lines @@
         listener.cancel('duplicate definition', token: element.position());
         listener.cancel('existing definition', token: existing.position());
       }
     }
   }
 
   Element find(SourceString name) {
     return elements[name];
   }
 
-  Element lookupLocalMember(SourceString name) {
-    Element element = find(name);
-    if (element === null) return null;
-    return (this === element.getLibrary()) ? element : null;
-  }
-
   void forEachExport(f(Element element)) {
     elements.forEach((SourceString _, Element e) {
       if (this === e.getLibrary()
           && e.kind !== ElementKind.PREFIX
           && e.kind !== ElementKind.FOREIGN) {
         f(e);
       }
     });
   }
 }
 
 class PrefixElement extends Element {
-  final LiteralString prefix;
-  final LibraryElement library;
+  Map<SourceString, Element> imported;
 
-  PrefixElement(LiteralString prefix,
-                LibraryElement this.library,
-                Element enclosing)
-    : this.prefix = prefix,
-      super(prefix.dartString.source, ElementKind.PREFIX, enclosing);
+  PrefixElement(SourceString prefix, Element enclosing)
+    : imported = new Map<SourceString, Element>(),
+      super(prefix, ElementKind.PREFIX, enclosing);
 
-  lookupLocalMember(SourceString name) => library.lookupLocalMember(name);
+  lookupLocalMember(SourceString name) => imported[name];
+
+  Type computeType(Compiler compiler) => compiler.types.dynamicType;
 }
 
 class TypedefElement extends Element {
   TypedefElement(SourceString name, Element enclosing)
     : super(name, ElementKind.TYPEDEF, enclosing);
 }
 
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
@@ skipping 28 matching lines @@
   Type computeType(Compiler compiler) {
     return variables.computeType(compiler);
   }
 
   Type get type() => variables.type;
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
 
-  Token position() {
-    // TODO(ahe): Record the token corresponding to name instead of
-    // returning different values at different points in time.
-    return (cachedNode !== null)
-        ? cachedNode.getBeginToken() : variables.position();
-  }
+  // Note: cachedNode.getBeginToken() will not be correct in all
+  // cases, for example, for function typed parameters.
+  Token position() => findMyName(variables.position());
 }
 
 // This element represents a list of variable or field declaration.
 // It contains the node, and the type. A [VariableElement] always
 // references its [VariableListElement]. It forwards its
 // [computeType] and [parseNode] methods to this element.
 class VariableListElement extends Element {
   VariableDefinitions cachedNode;
   Type type;
   final Modifiers modifiers;
@@ skipping 45 matching lines @@
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing),
         modifiers = new Modifiers.empty();
 
   Type computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
   }
 
   Node parseNode(DiagnosticListener listener) {
     throw "internal error: AbstractFieldElement has no node";
   }
+
+  position() {
+    // The getter and setter may be defined in two different
+    // compilation units.  However, we know that one of them is
+    // non-null and defined in the same compilation unit as the
+    // abstract element.
+    //
+    // We need to make sure that the position returned is relative to
+    // the compilation unit of the abstract element.
+    if (getter !== null && getter.enclosingElement === enclosingElement) {
+      return getter.position();
+    } else {
+      return setter.position();
+    }
+  }
 }
 
 /** DEPRECATED. */
 Type getType(TypeAnnotation typeAnnotation,
              Compiler compiler,
              LibraryElement library) {
   // TODO(karlklose,ngeoffray): This method should be removed and the
   // information should be computed by the resolver.
 
   if (typeAnnotation == null || typeAnnotation.typeName == null) {
     return compiler.types.dynamicType;
   }
   Identifier identifier = typeAnnotation.typeName.asIdentifier();
   if (identifier === null) {
-    compiler.cancel('library prefixes not handled',
-                    node: typeAnnotation.typeName);
+    compiler.reportWarning(typeAnnotation.typeName,
+                           'library prefixes not handled');
+    return compiler.types.dynamicType;
   }
   SourceString name = identifier.source;
   Element element = library.find(name);
   if (element !== null) {
     if (element.isTypedef()) {
       // TODO(ngeoffray): This is a hack to help us get support for the
       // DOM library.
       // TODO(ngeoffray): The list of types for the argument is wrong.
       return new FunctionType(compiler.types.dynamicType,
                               const EmptyLink<Type>(),
@@ skipping 404 matching lines @@
 
   LabelElement addLabel(Identifier label, String labelName) {
     LabelElement result = new LabelElement(label, labelName, this,
                                            enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 }