Fixes for translator and DDA status files.

pkg/analyzer_experimental/test/generated/resolver_test.dart

 // 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.resolver_test;
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 6671 matching lines @@
   }
   void fail_visitRedirectingConstructorInvocation() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _resolver = createResolver();
   }
+  void test_lookUpMethodInInterfaces() {
+    InterfaceType intType2 = _typeProvider.intType;
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    MethodElement operator = ElementFactory.methodElement("[]", intType2, [intType2]);
+    classA.methods = <MethodElement> [operator];
+    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    classB.interfaces = <InterfaceType> [classA.type];
+    ClassElementImpl classC = ElementFactory.classElement2("C", []);
+    classC.mixins = <InterfaceType> [classB.type];
+    ClassElementImpl classD = ElementFactory.classElement("D", classC.type, []);
+    SimpleIdentifier array = ASTFactory.identifier3("a");
+    array.staticType = classD.type;
+    IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.identifier3("i"));
+    JUnitTestCase.assertSame(operator, resolve5(expression, []));
+    _listener.assertNoErrors();
+  }
   void test_visitAssignmentExpression_compound() {
     InterfaceType intType2 = _typeProvider.intType;
     SimpleIdentifier leftHandSide = ASTFactory.identifier3("a");
     leftHandSide.staticType = intType2;
     AssignmentExpression assignment = ASTFactory.assignmentExpression(leftHandSide, TokenType.PLUS_EQ, ASTFactory.integer(1));
     resolveNode(assignment, []);
     JUnitTestCase.assertSame(getMethod(_typeProvider.numType, "+"), assignment.element);
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_simple() {
@@ skipping 463 matching lines @@
         statement.accept(_resolver);
       } finally {
         _visitor.labelScope_J2DAccessor = outerScope;
       }
     } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
   static dartSuite() {
     _ut.group('ElementResolverTest', () {
+      _ut.test('test_lookUpMethodInInterfaces', () {
+        final __test = new ElementResolverTest();
+        runJUnitTest(__test, __test.test_lookUpMethodInInterfaces);
+      });
       _ut.test('test_visitAssignmentExpression_compound', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_visitAssignmentExpression_compound);
       });
       _ut.test('test_visitAssignmentExpression_simple', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_visitAssignmentExpression_simple);
       });
       _ut.test('test_visitBinaryExpression', () {
         final __test = new ElementResolverTest();
@@ skipping 3549 matching lines @@
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
     JUnitTestCase.assertFalse(classes[0].hasReferenceToSuper());
     JUnitTestCase.assertTrue(classes[1].hasReferenceToSuper());
     assertNoErrors();
     verify([source]);
   }
-  void test_importWithPrefix() {
+  void test_import_hide() {
+    addSource2("lib1.dart", EngineTestCase.createSource(["library lib1;", "set foo(value) {}"]));
+    addSource2("lib2.dart", EngineTestCase.createSource(["library lib2;", "set foo(value) {}"]));
+    Source source = addSource2("lib3.dart", EngineTestCase.createSource(["import 'lib1.dart' hide foo;", "import 'lib2.dart';", "", "main() {", "  foo = 0;", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_import_prefix() {
     addSource2("/two.dart", EngineTestCase.createSource(["library two;", "f(int x) {", "  return x * x;", "}"]));
     Source source = addSource2("/one.dart", EngineTestCase.createSource(["library one;", "import 'two.dart' as _two;", "main() {", "  _two.f(0);", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_indexExpression_typeParameters() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  List<int> a;", "  a[0];", "  List<List<int>> b;", "  b[0][0];", "  List<List<List<int>>> c;", "  c[0][0][0];", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 195 matching lines @@
     ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration methodDeclaration = (classDeclaration.members[0] as MethodDeclaration);
     Block block2 = ((methodDeclaration.body as BlockFunctionBody)).block;
     ExpressionStatement statement = block2.statements[0] as ExpressionStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     NodeList<Expression> arguments2 = invocation.argumentList.arguments;
     int argumentCount = arguments2.length;
     JUnitTestCase.assertEquals(indices.length, argumentCount);
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments2[i];
-      ParameterElement element = argument.parameterElement;
+      ParameterElement element = argument.staticParameterElement;
       int index = indices[i];
       if (index < 0) {
         JUnitTestCase.assertNull(element);
       } else {
         JUnitTestCase.assertSame(parameters2[index], element);
       }
     }
   }
   static dartSuite() {
     _ut.group('SimpleResolverTest', () {
@@ skipping 78 matching lines @@
         runJUnitTest(__test, __test.test_functionTypeAlias);
       });
       _ut.test('test_getterAndSetterWithDifferentTypes', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_getterAndSetterWithDifferentTypes);
       });
       _ut.test('test_hasReferenceToSuper', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_hasReferenceToSuper);
       });
-      _ut.test('test_importWithPrefix', () {
+      _ut.test('test_import_hide', () {
         final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_importWithPrefix);
+        runJUnitTest(__test, __test.test_import_hide);
+      });
+      _ut.test('test_import_prefix', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_import_prefix);
       });
       _ut.test('test_indexExpression_typeParameters', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_indexExpression_typeParameters);
       });
       _ut.test('test_indexExpression_typeParameters_invalidAssignmentWarning', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_indexExpression_typeParameters_invalidAssignmentWarning);
       });
       _ut.test('test_indirectOperatorThroughCall', () {
@@ skipping 87 matching lines @@
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  PubSuggestionCodeTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }