Roll Observatory packages and add a roll script

packages/analyzer/lib/src/generated/testing/element_factory.dart

 // Copyright (c) 2014, 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.
 
-// This code was auto-generated, is not intended to be edited, and is subject to
-// significant change. Please see the README file for more information.
-
 library engine.testing.element_factory;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 172 matching lines @@
     }
     //
     // Finish building the enum.
     //
     enumElement.fields = fields;
     // Client code isn't allowed to invoke the constructor, so we do not model it.
     return enumElement;
   }
 
   static ExportElementImpl exportFor(LibraryElement exportedLibrary,
-      [List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_LIST]) {
+      [List<NamespaceCombinator> combinators =
+          NamespaceCombinator.EMPTY_LIST]) {
     ExportElementImpl spec = new ExportElementImpl(-1);
     spec.exportedLibrary = exportedLibrary;
     spec.combinators = combinators;
     return spec;
   }
 
   static FieldElementImpl fieldElement(
       String name, bool isStatic, bool isFinal, bool isConst, DartType type) {
     FieldElementImpl field = new FieldElementImpl(name, 0);
     field.const3 = isConst;
     field.final2 = isFinal;
     field.static = isStatic;
     field.type = type;
     PropertyAccessorElementImpl getter =
         new PropertyAccessorElementImpl.forVariable(field);
     getter.getter = true;
     getter.synthetic = true;
     getter.variable = field;
     getter.returnType = type;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
     getter.type = getterType;
     if (!isConst && !isFinal) {
       PropertyAccessorElementImpl setter =
           new PropertyAccessorElementImpl.forVariable(field);
       setter.setter = true;
       setter.synthetic = true;
       setter.variable = field;
-      setter.parameters =
-          <ParameterElement>[requiredParameter2("_$name", type)];
+      setter.parameters = <ParameterElement>[
+        requiredParameter2("_$name", type)
+      ];
       setter.returnType = VoidTypeImpl.instance;
       setter.type = new FunctionTypeImpl(setter);
       field.setter = setter;
     }
     return field;
   }
 
   static FieldFormalParameterElementImpl fieldFormalParameter(
-      Identifier name) => new FieldFormalParameterElementImpl(name);
+          Identifier name) =>
+      new FieldFormalParameterElementImpl(name);
 
   static FunctionElementImpl functionElement(String functionName) =>
       functionElement4(functionName, null, null, null, null);
 
   static FunctionElementImpl functionElement2(
           String functionName, ClassElement returnElement) =>
       functionElement3(functionName, returnElement, null, null);
 
-  static FunctionElementImpl functionElement3(String functionName,
-      ClassElement returnElement, List<ClassElement> normalParameters,
-      List<ClassElement> optionalParameters) {
+  static FunctionElementImpl functionElement3(
+      String functionName,
+      ClassElement returnElement,
+      List<TypeDefiningElement> normalParameters,
+      List<TypeDefiningElement> optionalParameters) {
     // We don't create parameter elements because we don't have parameter names
     FunctionElementImpl functionElement =
         new FunctionElementImpl(functionName, 0);
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     functionElement.type = functionType;
     // return type
     if (returnElement == null) {
       functionElement.returnType = VoidTypeImpl.instance;
     } else {
       functionElement.returnType = returnElement.type;
@@ skipping 13 matching lines @@
         parameter.type = optionalParameters[i - normalCount].type;
         parameter.parameterKind = ParameterKind.POSITIONAL;
       }
       parameters[i] = parameter;
     }
     functionElement.parameters = parameters;
     // done
     return functionElement;
   }
 
-  static FunctionElementImpl functionElement4(String functionName,
-      ClassElement returnElement, List<ClassElement> normalParameters,
-      List<String> names, List<ClassElement> namedParameters) {
+  static FunctionElementImpl functionElement4(
+      String functionName,
+      ClassElement returnElement,
+      List<ClassElement> normalParameters,
+      List<String> names,
+      List<ClassElement> namedParameters) {
     FunctionElementImpl functionElement =
         new FunctionElementImpl(functionName, 0);
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     functionElement.type = functionType;
     // parameters
     int normalCount = normalParameters == null ? 0 : normalParameters.length;
     int nameCount = names == null ? 0 : names.length;
     int typeCount = namedParameters == null ? 0 : namedParameters.length;
     if (names != null && nameCount != typeCount) {
       throw new IllegalStateException(
@@ skipping 22 matching lines @@
     } else {
       functionElement.returnType = returnElement.type;
     }
     return functionElement;
   }
 
   static FunctionElementImpl functionElement5(
           String functionName, List<ClassElement> normalParameters) =>
       functionElement3(functionName, null, normalParameters, null);
 
-  static FunctionElementImpl functionElement6(String functionName,
-      List<ClassElement> normalParameters,
-      List<ClassElement> optionalParameters) => functionElement3(
+  static FunctionElementImpl functionElement6(
+          String functionName,
+          List<ClassElement> normalParameters,
+          List<ClassElement> optionalParameters) =>
+      functionElement3(
           functionName, null, normalParameters, optionalParameters);
 
-  static FunctionElementImpl functionElement7(String functionName,
-      List<ClassElement> normalParameters, List<String> names,
-      List<ClassElement> namedParameters) => functionElement4(
+  static FunctionElementImpl functionElement7(
+          String functionName,
+          List<ClassElement> normalParameters,
+          List<String> names,
+          List<ClassElement> namedParameters) =>
+      functionElement4(
           functionName, null, normalParameters, names, namedParameters);
 
+  static FunctionElementImpl functionElement8(
+      List<DartType> parameters, DartType returnType,
+      {List<DartType> optional, Map<String, DartType> named}) {
+    List<ParameterElement> parameterElements = new List<ParameterElement>();
+    for (int i = 0; i < parameters.length; i++) {
+      ParameterElementImpl parameterElement =
+          new ParameterElementImpl("a$i", i);
+      parameterElement.type = parameters[i];
+      parameterElement.parameterKind = ParameterKind.REQUIRED;
+      parameterElements.add(parameterElement);
+    }
+    if (optional != null) {
+      int j = parameters.length;
+      for (int i = 0; i < optional.length; i++) {
+        ParameterElementImpl parameterElement =
+            new ParameterElementImpl("o$i", j);
+        parameterElement.type = optional[i];
+        parameterElement.parameterKind = ParameterKind.POSITIONAL;
+        parameterElements.add(parameterElement);
+        j++;
+      }
+    } else if (named != null) {
+      int j = parameters.length;
+      for (String s in named.keys) {
+        ParameterElementImpl parameterElement = new ParameterElementImpl(s, j);
+        parameterElement.type = named[s];
+        parameterElement.parameterKind = ParameterKind.NAMED;
+        parameterElements.add(parameterElement);
+      }
+    }
+
+    return functionElementWithParameters("f", returnType, parameterElements);
+  }
+
   static FunctionElementImpl functionElementWithParameters(String functionName,
       DartType returnType, List<ParameterElement> parameters) {
     FunctionElementImpl functionElement =
         new FunctionElementImpl(functionName, 0);
     functionElement.returnType =
         returnType == null ? VoidTypeImpl.instance : returnType;
     functionElement.parameters = parameters;
     FunctionTypeImpl functionType = new FunctionTypeImpl(functionElement);
     functionElement.type = functionType;
     return functionElement;
@@ skipping 28 matching lines @@
   static HtmlElementImpl htmlUnit(AnalysisContext context, String fileName) {
     Source source =
         new NonExistingSource(fileName, toUri(fileName), UriKind.FILE_URI);
     HtmlElementImpl unit = new HtmlElementImpl(context, fileName);
     unit.source = source;
     return unit;
   }
 
   static ImportElementImpl importFor(
       LibraryElement importedLibrary, PrefixElement prefix,
-      [List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_LIST]) {
+      [List<NamespaceCombinator> combinators =
+          NamespaceCombinator.EMPTY_LIST]) {
     ImportElementImpl spec = new ImportElementImpl(0);
     spec.importedLibrary = importedLibrary;
     spec.prefix = prefix;
     spec.combinators = combinators;
     return spec;
   }
 
   static LibraryElementImpl library(
       AnalysisContext context, String libraryName) {
     String fileName = "/$libraryName.dart";
     CompilationUnitElementImpl unit = compilationUnit(fileName);
     LibraryElementImpl library =
-        new LibraryElementImpl(context, libraryName, 0);
+        new LibraryElementImpl(context, libraryName, 0, libraryName.length);
     library.definingCompilationUnit = unit;
     return library;
   }
 
   static LocalVariableElementImpl localVariableElement(Identifier name) =>
       new LocalVariableElementImpl.forNode(name);
 
   static LocalVariableElementImpl localVariableElement2(String name) =>
       new LocalVariableElementImpl(name, 0);
 
@@ skipping 12 matching lines @@
         parameters[i] = parameter;
       }
       method.parameters = parameters;
     }
     method.returnType = returnType;
     FunctionTypeImpl methodType = new FunctionTypeImpl(method);
     method.type = methodType;
     return method;
   }
 
-  static MethodElementImpl methodElementWithParameters(String methodName,
-      List<DartType> typeArguments, DartType returnType,
+  static MethodElementImpl methodElementWithParameters(
+      String methodName,
+      List<DartType> typeArguments,
+      DartType returnType,
       List<ParameterElement> parameters) {
     MethodElementImpl method = new MethodElementImpl(methodName, 0);
     method.parameters = parameters;
     method.returnType = returnType;
     FunctionTypeImpl methodType = new FunctionTypeImpl(method);
     methodType.typeArguments = typeArguments;
     method.type = methodType;
     return method;
   }
 
@@ skipping 96 matching lines @@
     variable.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
     getter.type = getterType;
     if (!isConst && !isFinal) {
       PropertyAccessorElementImpl setter =
           new PropertyAccessorElementImpl.forVariable(variable);
       setter.setter = true;
       setter.static = true;
       setter.synthetic = true;
       setter.variable = variable;
-      setter.parameters =
-          <ParameterElement>[requiredParameter2("_$name", type)];
+      setter.parameters = <ParameterElement>[
+        requiredParameter2("_$name", type)
+      ];
       setter.returnType = VoidTypeImpl.instance;
       setter.type = new FunctionTypeImpl(setter);
       variable.setter = setter;
     }
     return variable;
   }
 
   static TypeParameterElementImpl typeParameterElement(String name) {
     TypeParameterElementImpl element = new TypeParameterElementImpl(name, 0);
     element.type = new TypeParameterTypeImpl(element);
     return element;
   }
 }