Revert "Update all Angular libs (run update_all.sh)."

third_party/pkg/angular/lib/tools/source_metadata_extractor.dart

 library angular.source_metadata_extractor ;
 
 import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/element.dart';
 
 import 'package:angular/tools/source_crawler.dart';
 import 'package:angular/tools/common.dart';
 
 const String _COMPONENT = '-component';
 const String _DIRECTIVE = '-directive';
 String _ATTR_DIRECTIVE = '-attr' + _DIRECTIVE;
 RegExp _ATTR_SELECTOR_REGEXP = new RegExp(r'\[([^\]]+)\]');
 const List<String> _specs = const ['=>!', '=>', '<=>', '@', '&'];
 const Map<String, String> _attrAnnotationsToSpec = const {
@@ skipping 77 matching lines @@
                 substring(0, className.length - _DIRECTIVE.length);
           } else {
             throw "Directive name '$className' must have a \$selector field.";
           }
         }
       }
       var reprocessedAttrs = <String>[];
       dirInfo.expressionAttrs.forEach((String attr) {
         if (attr == '.') {
           var matches = _ATTR_SELECTOR_REGEXP.allMatches(dirInfo.selector);
-          if (matches.isNotEmpty) {
+          if (matches.length > 0) {
             reprocessedAttrs.add(matches.last.group(1));
           }
         } else {
           reprocessedAttrs.add(attr);
         }
       });
       dirInfo.expressionAttrs = reprocessedAttrs;
       directives.add(dirInfo);
+
     });
 
-    directives.addAll(metadataVisitor.templates.map(
-        (tmpl) => new DirectiveInfo()..template = tmpl));
-
     return directives;
   }
 }
 
-class DirectiveMetadataCollectingAstVisitor extends RecursiveAstVisitor {
-  final List<DirectiveMetadata> metadata;
-  final List<String> templates;
+class DirectiveMetadataCollectingVisitor {
+  List<DirectiveMetadata> metadata = <DirectiveMetadata>[];
 
-  DirectiveMetadataCollectingAstVisitor(this.metadata, this.templates);
+  call(CompilationUnit cu) {
+    cu.declarations.forEach((CompilationUnitMember declaration) {
+      // We only care about classes.
+      if (declaration is! ClassDeclaration) return;
+      ClassDeclaration clazz = declaration;
+      // Check class annotations for presense of NgComponent/NgDirective.
+      DirectiveMetadata meta;
+      clazz.metadata.forEach((Annotation ann) {
+        if (ann.arguments == null) return; // Ignore non-class annotations.
+        // TODO(pavelj): this is not a safe check for the type of the
+        // annotations, but good enough for now.
+        if (ann.name.name != 'NgComponent'
+            && ann.name.name != 'NgDirective') return;
 
-  visitMethodInvocation(MethodInvocation node) {
-    if (node.methodName.name == 'ngRoute') {
-      NamedExpression viewHtmlExpression =
-          node.argumentList.arguments
-          .firstWhere((e) => e is NamedExpression &&
-              e.name.label.name == 'viewHtml', orElse: () => null);
-      if (viewHtmlExpression != null) {
-        if (viewHtmlExpression.expression is! StringLiteral) {
-          throw 'viewHtml must be a string literal';
-        }
-        templates.add(
-            (viewHtmlExpression.expression as StringLiteral).stringValue);
-      }
-    }
-    super.visitMethodInvocation(node);
-  }
+        bool isComponent = ann.name.name == 'NgComponent';
 
-  visitClassDeclaration(ClassDeclaration clazz) {
-    // Check class annotations for presense of Component/Decorator.
-    clazz.metadata.forEach((Annotation ann) {
-      if (ann.arguments == null) return; // Ignore non-class annotations.
-      // TODO(pavelj): this is not a safe check for the type of the
-      // annotations, but good enough for now.
-      if (ann.name.name != 'Component'
-          && ann.name.name != 'Decorator') return;
+        meta = new DirectiveMetadata()
+          ..className = clazz.name.name
+          ..type = isComponent ? COMPONENT : DIRECTIVE;
+        metadata.add(meta);
 
-      bool isComponent = ann.name.name == 'Component';
-
-      var meta = new DirectiveMetadata()
-        ..className = clazz.name.name
-        ..type = isComponent ? COMPONENT : DIRECTIVE;
-      metadata.add(meta);
-
-      ann.arguments.arguments.forEach((Expression arg) {
-        if (arg is NamedExpression) {
-          NamedExpression namedArg = arg;
-          var paramName = namedArg.name.label.name;
-          if (paramName == 'selector') {
-            meta.selector = assertString(namedArg.expression).stringValue;
+        ann.arguments.arguments.forEach((Expression arg) {
+          if (arg is NamedExpression) {
+            NamedExpression namedArg = arg;
+            var paramName = namedArg.name.label.name;
+            if (paramName == 'selector') {
+              meta.selector = assertString(namedArg.expression).stringValue;
+            }
+            if (paramName == 'template') {
+              meta.template = assertString(namedArg.expression).stringValue;
+            }
+            if (paramName == 'map') {
+              MapLiteral map = namedArg.expression;
+              map.entries.forEach((MapLiteralEntry entry) {
+                meta.attributeMappings[assertString(entry.key).stringValue] =
+                    assertString(entry.value).stringValue;
+              });
+            }
+            if (paramName == 'exportExpressions') {
+              meta.exportExpressions = getStringValues(namedArg.expression);
+            }
+            if (paramName == 'exportExpressionAttrs') {
+              meta.exportExpressionAttrs = getStringValues(namedArg.expression);
+            }
           }
-          if (paramName == 'template') {
-            meta.template = assertString(namedArg.expression).stringValue;
-          }
-          if (paramName == 'map') {
-            MapLiteral map = namedArg.expression;
-            map.entries.forEach((MapLiteralEntry entry) {
-              meta.attributeMappings[assertString(entry.key).stringValue] =
-                  assertString(entry.value).stringValue;
-            });
-          }
-          if (paramName == 'exportExpressions') {
-            meta.exportExpressions = getStringValues(namedArg.expression);
-          }
-          if (paramName == 'exportExpressionAttrs') {
-            meta.exportExpressionAttrs = getStringValues(namedArg.expression);
-          }
-        }
+        });
       });
 
-      if (meta != null) _walkSuperclassChain(clazz, meta, _extractMappingsFromClass);
-    });
-
-    return super.visitClassDeclaration(clazz);
-  }
-
-  _walkSuperclassChain(ClassDeclaration clazz, DirectiveMetadata meta,
-                       metadataExtractor(ClassDeclaration clazz, DirectiveMetadata meta)) {
-    while (clazz != null) {
-      metadataExtractor(clazz, meta);
-      if (clazz.element != null && clazz.element.supertype != null) {
-        clazz = clazz.element.supertype.element.node;
-      } else {
-        clazz = null;
-      }
-    }
-  }
-
-  _extractMappingsFromClass(ClassDeclaration clazz, DirectiveMetadata meta) {
-    // Check fields/getters/setter for presence of attr mapping annotations.
-    clazz.members.forEach((ClassMember member) {
-      if (member is FieldDeclaration ||
-      (member is MethodDeclaration &&
-      (member.isSetter || member.isGetter))) {
-        member.metadata.forEach((Annotation ann) {
-          if (_attrAnnotationsToSpec.containsKey(ann.name.name)) {
-            String fieldName;
-            if (member is FieldDeclaration) {
-              fieldName = member.fields.variables.first.name.name;
-            } else { // MethodDeclaration
-              fieldName = (member as MethodDeclaration).name.name;
-            }
-            StringLiteral attNameLiteral = ann.arguments.arguments.first;
-            if (meta.attributeMappings
-            .containsKey(attNameLiteral.stringValue)) {
-              throw 'Attribute mapping already defined for '
-              '${clazz.name}.$fieldName';
-            }
-            meta.attributeMappings[attNameLiteral.stringValue] =
-            _attrAnnotationsToSpec[ann.name.name] + fieldName;
+      // Check fields/getters/setter for presense of attr mapping annotations.
+      if (meta != null) {
+        clazz.members.forEach((ClassMember member) {
+          if (member is FieldDeclaration ||
+              (member is MethodDeclaration &&
+                  (member.isSetter || member.isGetter))) {
+            member.metadata.forEach((Annotation ann) {
+              if (_attrAnnotationsToSpec.containsKey(ann.name.name)) {
+                String fieldName;
+                if (member is FieldDeclaration) {
+                  fieldName = member.fields.variables.first.name.name;
+                } else { // MethodDeclaration
+                  fieldName = (member as MethodDeclaration).name.name;
+                }
+                StringLiteral attNameLiteral = ann.arguments.arguments.first;
+                if (meta.attributeMappings
+                        .containsKey(attNameLiteral.stringValue)) {
+                  throw 'Attribute mapping already defined for $fieldName';
+                }
+                meta.attributeMappings[attNameLiteral.stringValue] =
+                    _attrAnnotationsToSpec[ann.name.name] + fieldName;
+              }
+            });
           }
         });
       }
     });
   }
 }
 
-class DirectiveMetadataCollectingVisitor {
-  List<DirectiveMetadata> metadata = <DirectiveMetadata>[];
-  List<String> templates = <String>[];
-
-  call(CompilationUnit cu) {
-    cu.accept(new DirectiveMetadataCollectingAstVisitor(metadata, templates));
-  }
-}
-
 List<String> getStringValues(ListLiteral listLiteral) {
   List<String> res = <String>[];
   for (Expression element in listLiteral.elements) {
     res.add(assertString(element).stringValue);
   }
   return res;
 }
 
 StringLiteral assertString(Expression key) {
   if (key is! StringLiteral) {
     throw 'must be a string literal: ${key.runtimeType}';
   }
   return key;
 }