Use file/offset/kind triplet as elements id.

pkg/analysis_server/test/services/index/store/codec_test.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.
 
 library test.services.src.index.store.codec;
 
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/store/codec.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../../abstract_single_unit.dart';
 import '../../../mocks.dart';
 import '../../../reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(_ContextCodecTest);
   runReflectiveTests(_ElementCodecTest);
@@ skipping 43 matching lines @@
 class _ElementCodecTest extends AbstractSingleUnitTest {
   ElementCodec codec;
   AnalysisContext context = new MockAnalysisContext('context');
   StringCodec stringCodec = new StringCodec();
 
   void setUp() {
     super.setUp();
     codec = new ElementCodec(stringCodec);
   }
 
+  void test_encode_CompilationUnitElement() {
+    addSource('/my_part.dart', '''
+part of my_lib;
+''');
+    resolveTestUnit('''
+library my_lib;
+part 'my_part.dart';
+''');
+    // defining unit
+    {
+      Element element = testLibraryElement.definingCompilationUnit;
+      expect(element.source.fullName, '/test.dart');
+      int id1 = codec.encode1(element);
+      int id2 = codec.encode2(element);
+      int id3 = codec.encode3(element);
+      expect(id1, isNonNegative);
+      expect(id2, element.nameOffset);
+      expect(id3, ElementKind.COMPILATION_UNIT.ordinal);
+      // decode
+      Element element2 = codec.decode(context, id1, id2, id3);
+      expect(element2, element);
+    }
+    // part
+    {
+      Element element = testLibraryElement.parts[0];
+      expect(element.source.fullName, '/my_part.dart');
+      int id1 = codec.encode1(element);
+      int id2 = codec.encode2(element);
+      int id3 = codec.encode3(element);
+      expect(id1, isNonNegative);
+      expect(id2, element.nameOffset);
+      expect(id3, ElementKind.COMPILATION_UNIT.ordinal);
+      // decode
+      Element element2 = codec.decode(context, id1, id2, id3);
+      expect(element2, element);
+    }
+  }
+
+  void test_encode_ConstructorElement_default_real() {
+    resolveTestUnit('''
+class A {
+  A();
+}
+''');
+    ClassElement classA = findElement('A');
+    ConstructorElement element = classA.constructors[0];
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, classA.nameOffset);
+    expect(id3, -100);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_ConstructorElement_default_synthetic() {

[Brian Wilkerson, 2015/04/09 14:06:25]

It would be good to have a test case for multiple synthetic constructors (from
mixins).

[scheglov, 2015/04/09 15:11:57]

Done.

+    resolveTestUnit('''
+class A {
+}
+''');
+    ClassElement classA = findElement('A');
+    ConstructorElement element = classA.constructors[0];
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, classA.nameOffset);
+    expect(id3, -100);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_ConstructorElement_named_real() {
+    resolveTestUnit('''
+class A {
+  A.foo();
+  A.bar();
+}
+''');
+    ClassElement classA = findElement('A');
+    ConstructorElement element = classA.getNamedConstructor('bar');
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, classA.nameOffset);
+    expect(id3, -101);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_getter_real() {
+    resolveTestUnit('''
+class A {
+  int get test => 42;
+}
+''');
+    PropertyAccessorElement element = findElement('test', ElementKind.GETTER);
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, element.nameOffset);
+    expect(id3, ElementKind.GETTER.ordinal);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_getter_synthetic() {
+    resolveTestUnit('''
+class A {
+  int test;
+}
+''');
+    FieldElement field = findElement('test', ElementKind.FIELD);
+    PropertyAccessorElement element = field.getter;
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, element.nameOffset);
+    expect(id3, ElementKind.GETTER.ordinal);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_LibraryElement() {
+    resolveTestUnit('''
+class A {
+  test() {}
+}
+''');
+    Element element = testLibraryElement;
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, element.nameOffset);
+    expect(id3, ElementKind.LIBRARY.ordinal);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_MethodElement() {
+    resolveTestUnit('''
+class A {
+  test() {}
+}
+''');
+    Element element = findElement('test');
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, element.nameOffset);
+    expect(id3, ElementKind.METHOD.ordinal);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_NameElement() {
+    Element element = new NameElement('test');
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, ElementCodec.NAMED_FILE_ID);
+    expect(id2, isNonNegative);
+    expect(id3, ElementCodec.NAMED_KIND_ID);
+  }
+
+  void test_encode_setter_real() {
+    resolveTestUnit('''
+class A {
+  void set test(x) {}
+}
+''');
+    PropertyAccessorElement element = findElement('test=', ElementKind.SETTER);
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, element.nameOffset);
+    expect(id3, ElementKind.SETTER.ordinal);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
+  void test_encode_setter_synthetic() {
+    resolveTestUnit('''
+class A {
+  int test;
+}
+''');
+    FieldElement field = findElement('test', ElementKind.FIELD);
+    PropertyAccessorElement element = field.setter;
+    int id1 = codec.encode1(element);
+    int id2 = codec.encode2(element);
+    int id3 = codec.encode3(element);
+    expect(id1, isNonNegative);
+    expect(id2, element.nameOffset);
+    expect(id3, ElementKind.SETTER.ordinal);
+    // decode
+    Element element2 = codec.decode(context, id1, id2, id3);
+    expect(element2, element);
+  }
+
   void test_encodeHash_notLocal() {
     resolveTestUnit('''
 class A {
   void mainA() {
     int foo; // A
   }
   void mainB() {
     int foo; // B
     int bar;
   }
 }
 ''');
     MethodElement mainA = findElement('mainA');
     MethodElement mainB = findElement('mainB');
     Element fooA = mainA.localVariables[0];
     Element fooB = mainB.localVariables[0];
     Element bar = mainB.localVariables[1];
     int id_fooA = codec.encodeHash(fooA);
     int id_fooB = codec.encodeHash(fooB);
     int id_bar = codec.encodeHash(bar);
     expect(id_fooA == id_fooB, isTrue);
     expect(id_fooA == id_bar, isFalse);
   }
-
-  void test_field() {
-    resolveTestUnit('''
-class A {
-  int field;
-}
-''');
-    FieldElement field = findElement('field', ElementKind.FIELD);
-    PropertyAccessorElement getter = field.getter;
-    PropertyAccessorElement setter = field.setter;
-    {
-      int id = codec.encode(getter, false);
-      expect(codec.decode(context, id), getter);
-    }
-    {
-      int id = codec.encode(setter, false);
-      expect(codec.decode(context, id), setter);
-    }
-    {
-      int id = codec.encode(field, false);
-      expect(codec.decode(context, id), field);
-    }
-  }
-
-  void test_filePackage_uriMix() {
-    MethodElement buildMethodElement(Source source) {
-      CompilationUnitElementImpl unitElement =
-          new CompilationUnitElementImpl('file.dart');
-      LibraryElementImpl libraryElement =
-          new LibraryElementImpl(null, 'lib', 0);
-      ClassElementImpl classElement = new ClassElementImpl('A', 0);
-      MethodElementImpl methodElement = new MethodElementImpl('m', 0);
-      unitElement.source = source;
-      libraryElement.definingCompilationUnit = unitElement;
-      unitElement.types = [classElement];
-      classElement.methods = [methodElement];
-      return methodElement;
-    }
-    // file:
-    int fileId;
-    {
-      Source source = new _TestSource('/my/file.dart', 'file:///my/file.dart');
-      var methodElement = buildMethodElement(source);
-      fileId = codec.encode(methodElement, true);
-    }
-    // package:
-    int packageId;
-    {
-      Source source =
-          new _TestSource('/my/file.dart', 'package:my_pkg/file.dart');
-      var methodElement = buildMethodElement(source);
-      packageId = codec.encode(methodElement, true);
-    }
-    // should be the same
-    expect(packageId, fileId);
-  }
-
-  void test_localLocalVariable() {
-    resolveTestUnit('''
-main() {
-  {
-    foo() {
-      int bar; // A
-    }
-  }
-  {
-    foo() {
-      int bar; // B
-    }
-  }
-}
-''');
-    {
-      LocalVariableElement element = findNodeElementAtString('bar; // A', null);
-      int id = codec.encode(element, false);
-      expect(codec.decode(context, id), element);
-    }
-    {
-      LocalVariableElement element = findNodeElementAtString('bar; // B', null);
-      int id = codec.encode(element, false);
-      expect(codec.decode(context, id), element);
-    }
-    // check strings, "foo" as a single string, no "foo@17" or "bar@35"
-    expect(stringCodec.nameToIndex, hasLength(4));
-    expect(stringCodec.nameToIndex, containsPair('file:///test.dart', 0));
-    expect(stringCodec.nameToIndex, containsPair('main', 1));
-    expect(stringCodec.nameToIndex, containsPair('foo', 2));
-    expect(stringCodec.nameToIndex, containsPair('bar', 3));
-  }
-
-  void test_localVariable() {
-    resolveTestUnit('''
-main() {
-  {
-    int foo; // A
-  }
-  {
-    int foo; // B
-  }
-}
-''');
-    {
-      LocalVariableElement element = findNodeElementAtString('foo; // A', null);
-      int id = codec.encode(element, false);
-      expect(codec.decode(context, id), element);
-    }
-    {
-      LocalVariableElement element = findNodeElementAtString('foo; // B', null);
-      int id = codec.encode(element, false);
-      expect(codec.decode(context, id), element);
-    }
-    // check strings, "foo" as a single string, no "foo@21" or "foo@47"
-    expect(stringCodec.nameToIndex, hasLength(3));
-    expect(stringCodec.nameToIndex, containsPair('file:///test.dart', 0));
-    expect(stringCodec.nameToIndex, containsPair('main', 1));
-    expect(stringCodec.nameToIndex, containsPair('foo', 2));
-  }
-
-  void test_notLocal() {
-    resolveTestUnit('''
-main() {
-  int foo;
-}
-''');
-    LocalVariableElement element = findElement('foo');
-    int id = codec.encode(element, false);
-    expect(codec.encode(element, false), id);
-    expect(codec.decode(context, id), element);
-    // check strings
-    expect(stringCodec.nameToIndex, hasLength(3));
-    expect(stringCodec.nameToIndex, containsPair('file:///test.dart', 0));
-    expect(stringCodec.nameToIndex, containsPair('main', 1));
-    expect(stringCodec.nameToIndex, containsPair('foo', 2));
-  }
-}
-
+}
+
 @reflectiveTest
 class _RelationshipCodecTest {
   StringCodec stringCodec = new StringCodec();
   RelationshipCodec codec;
 
   void setUp() {
     codec = new RelationshipCodec(stringCodec);
   }
 
   void test_all() {
     Relationship relationship = Relationship.getRelationship('my-relationship');
     int id = codec.encode(relationship);
     expect(codec.decode(id), relationship);
   }
 }
 
 @reflectiveTest
 class _StringCodecTest {
   StringCodec codec = new StringCodec();
 
   void test_all() {
     int idA = codec.encode('aaa');
     int idB = codec.encode('bbb');
     expect(codec.decode(idA), 'aaa');
     expect(codec.decode(idB), 'bbb');
   }
 }
-
-class _TestSource implements Source {
-  final String fullName;
-  final String encoding;
-
-  _TestSource(this.fullName, this.encoding);
-
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}