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 115 matching lines @@
     define(element, listener);
   }
 
   void define(Element element, DiagnosticListener listener) {
     if (element.kind == ElementKind.GETTER
         || element.kind == ElementKind.SETTER) {
       addGetterOrSetter(element, elements[element.name], listener);
     } else {
       Element existing = elements.putIfAbsent(element.name, () => element);
       if (existing !== element) {
-        listener.cancel('duplicate definition', token: element.position());
+        listener.cancel('duplicate definition $element', token: element.position());

[ngeoffray, 2012/03/10 22:36:51]

line too long

[ngeoffray, 2012/03/10 22:36:51]

definition 'of' ?

[ahe, 2012/03/11 13:01:50]

Done.

[ahe, 2012/03/11 13:01:50]

Debug code.

         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();
-  }
+  Token position() => findMyName(variables.position());

[ngeoffray, 2012/03/10 22:36:51]

Why don't you check cachedNode first before going into slow case?

[ahe, 2012/03/10 23:07:18]

Wouldn't be correct for function typed parameters.

[ngeoffray, 2012/03/10 23:11:27]

Could you please add that as a comment?

[ahe, 2012/03/11 13:01:50]

Done.

 }
 
 // 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() {
+    if (getter !== null && getter.enclosingElement === enclosingElement) {

[ngeoffray, 2012/03/10 22:36:51]

I don't understand the second check.

[ahe, 2012/03/10 23:07:18]

I'll add a comment explaining this.

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.

[ngeoffray, 2012/03/10 23:11:27]

I see, thanks for the comment!

+      return getter.position();
+    } else {
+      return setter.position();

[ngeoffray, 2012/03/10 22:36:51]

setter could be null

[ahe, 2012/03/10 23:07:18]

No. See my comment above.

+    }
+  }
 }
 
 /** 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;
 }