Build script tags.

dart/frog/leg/elements/elements.dart

 // Copyright (c) 2011, 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 32 matching lines @@
 
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Modifiers get modifiers() => null;
 
-
   Node parseNode(Canceler canceler, Logger logger) {
     canceler.cancel("Internal Error: Element.parseNode");
   }
 
   Type computeType(Compiler compiler) {
     compiler.internalError("Element.computeType.");
   }
 
   bool isFunction() => kind == ElementKind.FUNCTION;
   bool isMember() =>
@@ skipping 16 matching lines @@
   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();
 
   toString() => '$kind($name)';
 }
 
-class CompilationUnitElement extends Element {
+class EnclosingElement extends Element {

[ngeoffray, 2012/01/25 09:04:59]

EnclosingElement -> ContainerElement?

Because other elements can be enclosing (eg a method), calling this class
EnclosingElement makes things confusing.

[ahe, 2012/01/25 09:18:53]

I was planning on making the other elements subclasses of EnclosingElement. But
now I'm not sure that is a good idea. addMember is not an integral property of
what it means to be an EnclosingElement.

[ahe, 2012/01/25 09:28:53]

Done.

+  EnclosingElement(name, kind, enclosingElement) :
+    super(name, kind, enclosingElement);
+
+  abstract void addMember(Element element, Canceler canceler);
+}
+
+class CompilationUnitElement extends EnclosingElement {
   final Script script;
+  Link<Element> topLevelElements = const EmptyLink<Element>();
+  Link<ScriptTag> tags = const EmptyLink<ScriptTag>();
+  final Map<SourceString, Element> scope;
+
   CompilationUnitElement(Script script, Element enclosing)
     : super(new SourceString(script.name),
             ElementKind.COMPILATION_UNIT,
             enclosing),
-      this.script = script;
+      this.script = script,
+      this.scope = new Map<SourceString, Element>();
+
+  void addMember(Element element, Canceler canceler) {
+    topLevelElements = topLevelElements.prepend(element);
+    Element existing = scope.putIfAbsent(element.name, ()=>element);

[ngeoffray, 2012/01/25 09:04:59]

spaces around => ?

+    if (existing !== element) {

[ngeoffray, 2012/01/25 09:04:59]

Is this the right place to do it? Do we want a per-compilation unit error, or a
per-library error? It looks to me that the library will have to create the scope
and run through the topLevelElements of its compilation units, in order to
report duplicates.

[ahe, 2012/01/25 09:18:53]

You're right, there is not much value in reporting duplicates at this point. I
should remove the scope from compilation unit.

[ahe, 2012/01/25 09:28:53]

Done.

+      canceler.cancel('duplicate definition', token: element.position());
+      canceler.cancel('existing definition', token: existing.position());
+    }
+  }
+
+  void addTag(ScriptTag tag) {
+    tags = tags.prepend(tag);
+  }
 }
 
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers() => variables.modifiers;
 
   VariableElement(SourceString name,
                   VariableListElement this.variables,
@@ skipping 215 matching lines @@
         new Identifier.synthetic(''),
         new NodeList.empty(),
         new Block(new NodeList.empty()),
         null, null, null);
     return cachedNode;
   }
 
   Token position() => null;
 }
 
-class ClassElement extends Element {
+class ClassElement extends EnclosingElement {
   Type type;
   Type supertype;
   Link<Element> members = const EmptyLink<Element>();
   Map<SourceString, Element> localMembers;
   Map<SourceString, Element> constructors;
   Link<Type> interfaces = const EmptyLink<Type>();
   bool isResolved = false;
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const EmptyLink<Element>();
   SynthesizedConstructorElement synthesizedConstructor;
 
   ClassElement(SourceString name, CompilationUnitElement enclosing)
     : localMembers = new Map<SourceString, Element>(),
       constructors = new Map<SourceString, Element>(),
       super(name, ElementKind.CLASS, enclosing);
 
-  void addMember(Element element) {
+  void addMember(Element element, Canceler canceler) {
     members = members.prepend(element);
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
         element.modifiers.isFactory()) {
       constructors[element.name] = element;
     } else {
       localMembers[element.name] = element;
     }
   }
 
   Type computeType(compiler) {
@@ skipping 77 matching lines @@
     if (send.isPropertyAccess) return false;
     if (send.receiver !== null) return false;
     Element element = elements[send];
     // (o)() or foo()().
     if (element === null && send.selector.asIdentifier() === null) return true;
     if (element === null) return false;
     // foo() with foo a local or a parameter.
     return element.isVariable() || element.isParameter();
   }
 }