Update all Angular libs (run update_all.sh).

third_party/pkg/di/lib/generator.dart

 library di.generator;
 
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:path/path.dart' as path;
 
 import 'dart:io';
 
 const String PACKAGE_PREFIX = 'package:';
 const String DART_PACKAGE_PREFIX = 'dart:';
+const List<String> _DEFAULT_INJECTABLE_ANNOTATIONS =
+    const ['di.annotations.Injectable'];
 
-main(args) {
+main(List<String> args) {
   if (args.length < 4) {
     print('Usage: generator path_to_sdk file_to_resolve annotations output [package_roots+]');
     exit(0);
   }
 
   var pathToSdk = args[0];
   var entryPoint = args[1];
-  var classAnnotations = args[2].split(',');
+  var classAnnotations = args[2].split(',')
+      ..addAll(_DEFAULT_INJECTABLE_ANNOTATIONS);
   var output = args[3];
   var packageRoots = (args.length < 5) ? [Platform.packageRoot] : args.sublist(4);
 
   print('pathToSdk: $pathToSdk');
   print('entryPoint: $entryPoint');
   print('classAnnotations: ${classAnnotations.join(', ')}');
   print('output: $output');
   print('packageRoots: $packageRoots');
 
-  var code = generateCode(entryPoint, classAnnotations, pathToSdk, packageRoots);
+  var code = generateCode(entryPoint, classAnnotations, pathToSdk, packageRoots, output);
   code.forEach((chunk, code) {
     String fileName = output;
     if (chunk.library != null) {
       var lastDot = fileName.lastIndexOf('.');
       fileName = fileName.substring(0, lastDot) + '-' + chunk.library.name + fileName.substring(lastDot);
     }
     new File(fileName).writeAsStringSync(code);
   });
 }
 
 Map<Chunk, String> generateCode(String entryPoint, List<String> classAnnotations,
-    String pathToSdk, List<String> packageRoots) {
+    String pathToSdk, List<String> packageRoots, String outputFilename) {
   var c = new SourceCrawler(pathToSdk, packageRoots);
   List<String> imports = <String>[];
   Map<Chunk, List<ClassElement>> typeFactoryTypes = <Chunk, List<ClassElement>>{};
   Map<String, String> typeToImport = new Map<String, String>();
   c.crawl(entryPoint, (CompilationUnitElement compilationUnit, SourceFile source) {
       new CompilationUnitVisitor(c.context, source, classAnnotations, imports,
-          typeToImport, typeFactoryTypes).visit(compilationUnit, source);
+          typeToImport, typeFactoryTypes, outputFilename).visit(compilationUnit, source);
   });
   return printLibraryCode(typeToImport, imports, typeFactoryTypes);
 }
 
 Map<Chunk, String> printLibraryCode(Map<String, String> typeToImport,
     List<String> imports, Map<Chunk, List<ClassElement>> typeFactoryTypes) {
   Map<Chunk, StringBuffer> factories = <Chunk, StringBuffer>{};
   Map<Chunk, String> result = <Chunk, String>{};
   typeFactoryTypes.forEach((Chunk chunk, List<ClassElement> classes) {
     List<String> requiredImports = <String>[];
     String resolveClassIdentifier(InterfaceType type) {
       if (type.element.library.isDartCore) {
         return type.name;
       }
       String import = typeToImport[getCanonicalName(type)];
       if (!requiredImports.contains(import)) {
         requiredImports.add(import);
       }
-      return 'import_${imports.indexOf(import)}.${type.name}';
+      String prefix = _calculateImportPrefix(import, imports);
+      return '$prefix.${type.name}';
     }
     factories[chunk] = new StringBuffer();
     classes.forEach((ClassElement clazz) {
       StringBuffer factory = new StringBuffer();
       bool skip = false;
-      factory.write(
-          '${resolveClassIdentifier(clazz.type)}: (f) => ');
+      factory.write('${resolveClassIdentifier(clazz.type)}: (f) => ');
       factory.write('new ${resolveClassIdentifier(clazz.type)}(');
       ConstructorElement constr =
           clazz.constructors.firstWhere((c) => c.name.isEmpty,
           orElse: () {
-            throw 'Unable to find default constructor for $clazz in ${clazz.source}';
+            throw 'Unable to find default constructor for '
+                  '$clazz in ${clazz.source}';
           });
       factory.write(constr.parameters.map((param) {
         if (param.type.element is! ClassElement) {
           throw 'Unable to resolve type for constructor parameter '
-          '"${param.name}" for type "$clazz" in ${clazz.source}';
+                '"${param.name}" for type "$clazz" in ${clazz.source}';
         }
         if (_isParameterized(param)) {
-          print('WARNING: parameterized types are not supported: $param in $clazz in ${clazz.source}. Skipping!');
+          print('WARNING: parameterized types are not supported: '
+                '$param in $clazz in ${clazz.source}. Skipping!');
           skip = true;
         }
-        return 'f(${resolveClassIdentifier(param.type)})';
+        var annotations = [];
+        if (param.metadata.isNotEmpty) {
+          annotations = param.metadata.map(
+              (item) => resolveClassIdentifier(item.element.returnType));
+        }
+        StringBuffer output =
+            new StringBuffer('f(${resolveClassIdentifier(param.type)}');
+        if (annotations.isNotEmpty) {
+          output.write(', ${annotations.first}');
+        }
+        output.write(')');
+        return output;
       }).join(', '));
       factory.write('),\n');
       if (!skip) {
         factories[chunk].write(factory);
       }
     });
     StringBuffer code = new StringBuffer();
     String libSuffix = chunk.library == null ? '' : '.${chunk.library.name}';
     code.write('library di.generated.type_factories$libSuffix;\n');
     requiredImports.forEach((import) {
-      code.write ('import "$import" as import_${imports.indexOf(import)};\n');
+      String prefix = _calculateImportPrefix(import, imports);
+      code.write ('import "$import" as $prefix;\n');
     });
     code..write('var typeFactories = {\n${factories[chunk]}\n};\n')
         ..write('main() {}\n');
     result[chunk] = code.toString();
   });
 
   return result;
 }
 
+String _calculateImportPrefix(String import, List<String> imports) =>
+    'import_${imports.indexOf(import)}';
+
 _isParameterized(ParameterElement param) {
   String typeName = param.type.toString();
 
   if (typeName.indexOf('<') > -1) {
     String parameters =
         typeName.substring(typeName.indexOf('<') + 1, typeName.length - 1);
     return parameters.split(', ').any((p) => p != 'dynamic');
   }
   return false;
 }
 
 class CompilationUnitVisitor {
   List<String> imports;
   Map<String, String> typeToImport;
   Map<Chunk, List<ClassElement>> typeFactoryTypes;
   List<String> classAnnotations;
   SourceFile source;
   AnalysisContext context;
+  String outputFilename;
 
   CompilationUnitVisitor(this.context, this.source,
       this.classAnnotations, this.imports, this.typeToImport,
-      this.typeFactoryTypes);
+      this.typeFactoryTypes, this.outputFilename);
 
   visit(CompilationUnitElement compilationUnit, SourceFile source) {
+    if (typeFactoryTypes[source.chunk] == null) {
+      typeFactoryTypes[source.chunk] = <ClassElement>[];
+    }
     visitLibrary(compilationUnit.enclosingElement, source);
 
     List<ClassElement> types = <ClassElement>[];
     types.addAll(compilationUnit.types);
 
     for (CompilationUnitElement part in compilationUnit.enclosingElement.parts) {
       types.addAll(part.types);
     }
 
     types.forEach((clazz) => visitClassElement(clazz, source));
@@ skipping 13 matching lines @@
                 (ann.element as ConstructorElement).enclosingElement.type) ==
                 'di.annotations.Injectables') {
             var listLiteral =
                 library.metadata[annotationIdx].arguments.arguments.first;
             for (Expression expr in listLiteral.elements) {
               Element element = (expr as SimpleIdentifier).bestElement;
               if (element == null || element is! ClassElement) {
                 throw 'Unable to resolve type "$expr" from @Injectables '
                       'in ${library.element.source}';
               }
-              if (typeFactoryTypes[source.chunk] == null) {
-                typeFactoryTypes[source.chunk] = <ClassElement>[];
-              }
               if (!typeFactoryTypes[source.chunk].contains(element)) {
                 typeFactoryTypes[source.chunk].add(element as ClassElement);
               }
             }
           }
           annotationIdx++;
         });
       }
     });
   }
 
   visitClassElement(ClassElement classElement, SourceFile source) {
     if (classElement.name.startsWith('_')) {
       return; // ignore private classes.
     }
-    typeToImport[getCanonicalName(classElement.type)] =
-        source.entryPointImport;
-    if (!imports.contains(source.entryPointImport)) {
-      imports.add(source.entryPointImport);
+    var importUri = source.entryPointImport;
+    if (Uri.parse(importUri).scheme == '') {
+      importUri = path.relative(importUri, from: path.dirname(outputFilename));
+    }
+    typeToImport[getCanonicalName(classElement.type)] = importUri;
+    if (!imports.contains(importUri)) {
+      imports.add(importUri);
     }
     for (ElementAnnotation ann in classElement.metadata) {
       if (ann.element is ConstructorElement) {
         ConstructorElement con = ann.element;
         if (classAnnotations
             .contains(getQualifiedName(con.enclosingElement.type))) {
           if (typeFactoryTypes[source.chunk] == null) {
             typeFactoryTypes[source.chunk] = <ClassElement>[];
           }
           if (!typeFactoryTypes[source.chunk].contains(classElement)) {
@@ skipping 20 matching lines @@
 typedef CompilationUnitCrawler(CompilationUnitElement compilationUnit,
                                SourceFile source);
 
 class SourceCrawler {
   final List<String> packageRoots;
   final String sdkPath;
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
 
   SourceCrawler(this.sdkPath, this.packageRoots);
 
-  void crawl(String entryPoint, CompilationUnitCrawler _visitor) {
+  void crawl(String entryPoint, CompilationUnitCrawler _visitor,
+             {bool preserveComments : false}) {
     JavaSystemIO.setProperty("com.google.dart.sdk", sdkPath);
     DartSdk sdk = DirectoryBasedDartSdk.defaultSdk;
 
     AnalysisOptionsImpl contextOptions = new AnalysisOptionsImpl();
     contextOptions.cacheSize = 256;
-    contextOptions.preserveComments = false;
+    contextOptions.preserveComments = preserveComments;
     contextOptions.analyzeFunctionBodies = false;
     context.analysisOptions = contextOptions;
     sdk.context.analysisOptions = contextOptions;
 
     var packageUriResolver =
         new PackageUriResolver(packageRoots.map(
             (pr) => new JavaFile.fromUri(new Uri.file(pr))).toList());
-    context.sourceFactory = new SourceFactory.con2([
+    context.sourceFactory = new SourceFactory([
       new DartUriResolver(sdk),
       new FileUriResolver(),
       packageUriResolver
     ]);
 
     var entryPointFile;
     var entryPointImport;
     if (entryPoint.startsWith(PACKAGE_PREFIX)) {
       entryPointFile = new JavaFile(packageUriResolver
-          .resolveAbsolute(context.sourceFactory.contentCache,
-              Uri.parse(entryPoint)).toString());
+          .resolveAbsolute(Uri.parse(entryPoint)).toString());
       entryPointImport = entryPoint;
     } else {
       entryPointFile = new JavaFile(entryPoint);
       entryPointImport = entryPointFile.getAbsolutePath();
     }
 
-    Source source = new FileBasedSource.con1(
-        context.sourceFactory.contentCache, entryPointFile);
+    Source source = new FileBasedSource.con1(entryPointFile);
     ChangeSet changeSet = new ChangeSet();
-    changeSet.added(source);
+    changeSet.addedSource(source);
     context.applyChanges(changeSet);
     LibraryElement rootLib = context.computeLibraryElement(source);
     CompilationUnit resolvedUnit =
         context.resolveCompilationUnit(source, rootLib);
 
     var sourceFile = new SourceFile(
         entryPointFile.getAbsolutePath(),
         entryPointImport,
         resolvedUnit,
         resolvedUnit.element,
@@ skipping 185 matching lines @@
 
   SourceFile(this.canonicalPath, this.entryPointImport, this.compilationUnit,
       this.compilationUnitElement, this.chunk);
 
   operator ==(o) {
     if (o is String) return o == canonicalPath;
     if (o is! SourceFile) return false;
     return o.canonicalPath == canonicalPath;
   }
 }