Implement script tags.

dart/frog/leg/scanner/scanner_task.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.
 
 class ScannerTask extends CompilerTask {
   ScannerTask(Compiler compiler) : super(compiler);
   String get name() => 'Scanner';
 
   void scan(CompilationUnitElement compilationUnit) {
     measure(() {
       scanElements(compilationUnit);
       if (compilationUnit.kind === ElementKind.LIBRARY) {
         processScriptTags(compilationUnit);
       }
     });
   }
 
   void processScriptTags(LibraryElement library) {
-    for (ScriptTag tag in library.tags) {
-      compiler.reportWarning(tag, "library tags are not implemented");
+    for (ScriptTag tag in library.tags.reverse()) {
+      SourceString argument = tag.argument.value.copyWithoutQuotes(1, 1);
+      Uri cwd = new Uri(scheme: 'file', path: compiler.currentDirectory);
+      Uri base = cwd.resolve(library.script.name.toString());
+      Uri resolved = base.resolve(argument.toString());
+      if (tag.isImport()) {
+        importLibrary(library, loadLibrary(resolved, tag), tag.prefix);
+      } else if (tag.isLibrary()) {
+        if (library.libraryTag !== null) {
+          compiler.cancel("duplicated library declaration", node: tag);
+        } else {
+          library.libraryTag = tag;
+        }
+      } else if (tag.isSource()) {
+        Script script = compiler.readScript(resolved, tag);
+        CompilationUnitElement unit =
+          new CompilationUnitElement(script, library);
+        compiler.withCurrentElement(unit, () => scan(unit));
+      } else {
+        compiler.cancel("illegal script tag: ${tag.tag}", node: tag);
+      }
     }
     if (library !== compiler.coreLibrary) {
       importLibrary(library, compiler.coreLibrary, null);
     }
   }
 
   void scanElements(CompilationUnitElement compilationUnit) {
     compiler.log("scanning $compilationUnit");
     Script script = compilationUnit.script;
     Token tokens;
     try {
       tokens = new StringScanner(script.text).tokenize();
     } catch (MalformedInputException ex) {
       Token token;
       var message;
       if (ex.position is num) {
         // TODO(ahe): Always use tokens in MalformedInputException.
         token = new Token(EOF_INFO, ex.position);
       } else {
         token = ex.position;
       }
       compiler.cancel(ex.message, token: token);
     }
     ElementListener listener = new ElementListener(compiler, compilationUnit);
     PartialParser parser = new PartialParser(listener);
     parser.parseUnit(tokens);
   }
 
+  LibraryElement loadLibrary(Uri uri, ScriptTag node) {
+    bool newLibrary = false;
+    LibraryElement library =
+      compiler.universe.libraries.putIfAbsent(uri.toString(), () {
+          newLibrary = true;

[kasperl, 2012/02/03 11:51:37]

Weird indentation.

[ahe, 2012/02/03 17:36:19]

This is what Dart mode in Emacs does. What would you like to see?

[kasperl, 2012/02/05 07:58:29]

I'd much prefer something like this:

   xxx.yyy.zzz(..., () {
     hest;
     fisk;
   });

Looks more like regular control flow that way.

[sra1, 2012/02/05 19:01:38]

Emacs is closer to the style guide.

Style guide says "DO indent continued lines with four spaces."
Since there are two levels of nesting here, ({, I think the body should be
indented not less than +4.

If you broke the arguments at the comma, you should have +4 for "() {" and
another +2 for the body.

+          Script script = compiler.readScript(uri, node);
+          return new LibraryElement(script);
+        });
+    if (newLibrary) {
+      compiler.withCurrentElement(library, () => scan(library));
+    }
+    return library;
+  }
+
   void importLibrary(LibraryElement library, LibraryElement imported,
                      LiteralString prefix) {
     if (prefix !== null) {
-      withCurrentElement(library, () {
-          compiler.cancel("prefixes are not implemented", node: prefix);
-        });
+      library.define(new PrefixElement(prefix, imported, library), compiler);
     } else {
       for (Link<Element> link = imported.topLevelElements; !link.isEmpty();
            link = link.tail) {
         compiler.withCurrentElement(link.head, () {
             library.define(link.head, compiler);
           });
       }
     }
   }
 }