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 ContainerElement extends Element {
+  ContainerElement(name, kind, enclosingElement) :
+    super(name, kind, enclosingElement);
+
+  abstract void addMember(Element element, Canceler canceler);
+}
+
+class CompilationUnitElement extends ContainerElement {
   final Script script;
+  Link<Element> topLevelElements = const EmptyLink<Element>();
+  Link<ScriptTag> tags = const EmptyLink<ScriptTag>();
+
   CompilationUnitElement(Script script, Element enclosing)
     : super(new SourceString(script.name),
             ElementKind.COMPILATION_UNIT,
             enclosing),
       this.script = script;
+
+  void addMember(Element element, Canceler canceler) {
+    topLevelElements = topLevelElements.prepend(element);
+  }
+
+  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 ContainerElement {
   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();
   }
 }