Compute unlinked API signatures from AST.
With this change summary2 does not use content hash as API signature,
so can reuse linked bundles when method bodies are changed.
The implementation of the API signature computation is from:
https://dart-review.googlesource.com/74925
R=brianwilkerson@google.com, paulberry@google.com
Change-Id: I2a53957b8fff5208055aa28a188d6481ba24f5df
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/105321
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index 5d2d805..0620474 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -93,7 +93,7 @@
/**
* The version of data format, should be incremented on every format change.
*/
- static const int DATA_VERSION = 80;
+ static const int DATA_VERSION = 81;
/**
* The number of exception contexts allowed to write. Once this field is
diff --git a/pkg/analyzer/lib/src/dart/analysis/file_state.dart b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
index 1976c01..f26ea36 100644
--- a/pkg/analyzer/lib/src/dart/analysis/file_state.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
@@ -16,6 +16,7 @@
import 'package:analyzer/src/dart/analysis/library_graph.dart';
import 'package:analyzer/src/dart/analysis/performance_logger.dart';
import 'package:analyzer/src/dart/analysis/referenced_names.dart';
+import 'package:analyzer/src/dart/analysis/unlinked_api_signature.dart';
import 'package:analyzer/src/dart/scanner/reader.dart';
import 'package:analyzer/src/dart/scanner/scanner.dart';
import 'package:analyzer/src/generated/engine.dart';
@@ -659,7 +660,7 @@
CompilationUnit unit = parse();
_unitForLinking = unit;
_fsState._logger.run('Create unlinked for $path', () {
- var unlinkedUnit = serializeAstUnlinked2(contentSignature, unit);
+ var unlinkedUnit = serializeAstUnlinked2(unit);
var definedNames = computeDefinedNames(unit);
var referencedNames = computeReferencedNames(unit).toList();
var subtypedNames = computeSubtypedNames(unit).toList();
@@ -759,8 +760,7 @@
return apiSignatureChanged;
}
- static UnlinkedUnit2Builder serializeAstUnlinked2(
- List<int> contentSignature, CompilationUnit unit) {
+ static UnlinkedUnit2Builder serializeAstUnlinked2(CompilationUnit unit) {
var exports = <String>[];
var imports = <String>['dart:core'];
var parts = <String>[];
@@ -784,7 +784,7 @@
}
var informativeData = createInformativeData(unit);
return UnlinkedUnit2Builder(
- apiSignature: contentSignature,
+ apiSignature: computeUnlinkedApiSignature(unit),
exports: exports,
imports: imports,
parts: parts,
diff --git a/pkg/analyzer/lib/src/dart/analysis/unlinked_api_signature.dart b/pkg/analyzer/lib/src/dart/analysis/unlinked_api_signature.dart
new file mode 100644
index 0000000..dfbaf6a
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/analysis/unlinked_api_signature.dart
@@ -0,0 +1,134 @@
+// Copyright (c) 2019, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/src/dart/ast/token.dart';
+import 'package:analyzer/src/summary/api_signature.dart';
+
+/// Return the bytes of the unlinked API signature of the given [unit].
+///
+/// If API signatures of two units are different, they may have different APIs.
+List<int> computeUnlinkedApiSignature(CompilationUnit unit) {
+ var computer = new _UnitApiSignatureComputer();
+ computer.compute(unit);
+ return computer.signature.toByteList();
+}
+
+class _UnitApiSignatureComputer {
+ final signature = new ApiSignature();
+
+ void addClassOrMixin(ClassOrMixinDeclaration node) {
+ addTokens(node.beginToken, node.leftBracket);
+
+ bool hasConstConstructor = node.members
+ .any((m) => m is ConstructorDeclaration && m.constKeyword != null);
+
+ signature.addInt(node.members.length);
+ for (var member in node.members) {
+ if (member is ConstructorDeclaration) {
+ var lastInitializer = member.constKeyword != null &&
+ member.initializers != null &&
+ member.initializers.isNotEmpty
+ ? member.initializers.last
+ : null;
+ addTokens(
+ member.beginToken,
+ (lastInitializer ?? member.parameters ?? member.name).endToken,
+ );
+ } else if (member is FieldDeclaration) {
+ var variableList = member.fields;
+ addVariables(
+ member,
+ variableList,
+ !member.isStatic && variableList.isFinal && hasConstConstructor,
+ );
+ } else if (member is MethodDeclaration) {
+ addTokens(
+ member.beginToken,
+ (member.parameters ?? member.name).endToken,
+ );
+ } else {
+ addNode(member);
+ }
+ }
+
+ addToken(node.rightBracket);
+ }
+
+ void addNode(AstNode node) {
+ addTokens(node.beginToken, node.endToken);
+ }
+
+ void addToken(Token token) {
+ signature.addString(token.lexeme);
+ }
+
+ /// Appends tokens from [begin] (including), to [end] (also including).
+ void addTokens(Token begin, Token end) {
+ if (begin is CommentToken) {
+ begin = (begin as CommentToken).parent;
+ }
+
+ Token token = begin;
+ while (token != null) {
+ addToken(token);
+
+ if (token == end) {
+ break;
+ }
+
+ var nextToken = token.next;
+
+ // Stop if EOF.
+ if (nextToken == token) {
+ break;
+ }
+
+ token = nextToken;
+ }
+ }
+
+ void addVariables(
+ AstNode node,
+ VariableDeclarationList variableList,
+ bool includeInitializers,
+ ) {
+ if (variableList.type == null ||
+ variableList.isConst ||
+ includeInitializers) {
+ addTokens(node.beginToken, node.endToken);
+ } else {
+ addTokens(node.beginToken, variableList.type.endToken);
+
+ signature.addInt(variableList.variables.length);
+ for (var variable in variableList.variables) {
+ addTokens(variable.beginToken, variable.name.endToken);
+ addToken(variable.endToken.next); // `,` or `;`
+ }
+ }
+ }
+
+ void compute(CompilationUnit unit) {
+ signature.addInt(unit.directives.length);
+ unit.directives.forEach(addNode);
+
+ signature.addInt(unit.declarations.length);
+ for (var declaration in unit.declarations) {
+ if (declaration is ClassOrMixinDeclaration) {
+ addClassOrMixin(declaration);
+ } else if (declaration is FunctionDeclaration) {
+ var parameters = declaration.functionExpression.parameters;
+ addTokens(
+ declaration.beginToken,
+ (parameters ?? declaration.name).endToken,
+ );
+ } else if (declaration is TopLevelVariableDeclaration) {
+ addVariables(declaration, declaration.variables, false);
+ } else {
+ addNode(declaration);
+ }
+ }
+ }
+}
diff --git a/pkg/analyzer/test/src/dart/analysis/test_all.dart b/pkg/analyzer/test/src/dart/analysis/test_all.dart
index 481b428..689b3d4 100644
--- a/pkg/analyzer/test/src/dart/analysis/test_all.dart
+++ b/pkg/analyzer/test/src/dart/analysis/test_all.dart
@@ -26,6 +26,7 @@
import 'search_test.dart' as search;
import 'session_helper_test.dart' as session_helper;
import 'session_test.dart' as session;
+import 'unlinked_api_signature_test.dart' as unlinked_api_signature;
import 'uri_converter_test.dart' as uri_converter;
main() {
@@ -52,6 +53,7 @@
search.main();
session.main();
session_helper.main();
+ unlinked_api_signature.main();
uri_converter.main();
}, name: 'analysis');
}
diff --git a/pkg/analyzer/test/src/dart/analysis/unlinked_api_signature_test.dart b/pkg/analyzer/test/src/dart/analysis/unlinked_api_signature_test.dart
new file mode 100644
index 0000000..8222c70
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/analysis/unlinked_api_signature_test.dart
@@ -0,0 +1,851 @@
+// Copyright (c) 2019, 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.
+
+import 'package:analyzer/src/dart/analysis/unlinked_api_signature.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../ast/parse_base.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(UnitApiSignatureTest);
+ });
+}
+
+@reflectiveTest
+class UnitApiSignatureTest extends ParseBase {
+ void assertNotSameSignature(String oldCode, String newCode) {
+ assertSignature(oldCode, newCode, same: false);
+ }
+
+ void assertSameSignature(String oldCode, String newCode) {
+ assertSignature(oldCode, newCode, same: true);
+ }
+
+ void assertSignature(String oldCode, String newCode, {bool same}) {
+ var path = convertPath('/test.dart');
+
+ newFile(path, content: oldCode);
+ var oldUnit = parseUnit(path).unit;
+ var oldSignature = computeUnlinkedApiSignature(oldUnit);
+
+ newFile(path, content: newCode);
+ var newUnit = parseUnit(path).unit;
+ var newSignature = computeUnlinkedApiSignature(newUnit);
+
+ if (same) {
+ expect(newSignature, oldSignature);
+ } else {
+ expect(newSignature, isNot(oldSignature));
+ }
+ }
+
+ test_class_annotation() async {
+ assertNotSameSignature(r'''
+const a = 0;
+
+class C {}
+''', r'''
+const a = 0;
+
+@a
+class C {}
+''');
+ }
+
+ test_class_constructor_block_to_empty() {
+ assertSameSignature(r'''
+class C {
+ C() {
+ var v = 1;
+ }
+}
+''', r'''
+class C {
+ C();
+}
+''');
+ }
+
+ test_class_constructor_body() {
+ assertSameSignature(r'''
+class C {
+ C() {
+ var v = 1;
+ }
+}
+''', r'''
+class C {
+ C() {
+ var v = 2;
+ }
+}
+''');
+ }
+
+ test_class_constructor_empty_to_block() {
+ assertSameSignature(r'''
+class C {
+ C();
+}
+''', r'''
+class C {
+ C() {
+ var v = 1;
+ }
+}
+''');
+ }
+
+ test_class_constructor_initializer_const() {
+ assertNotSameSignature(r'''
+class C {
+ final int f;
+ const C() : f = 1;
+}
+''', r'''
+class C {
+ final int f;
+ const C() : f = 2;
+}
+''');
+ }
+
+ test_class_constructor_initializer_empty() {
+ assertSameSignature(r'''
+class C {
+ C.foo() : ;
+}
+''', r'''
+class C {
+ C.foo() : f;
+}
+''');
+ }
+
+ test_class_constructor_initializer_notConst() {
+ assertSameSignature(r'''
+class C {
+ final int f;
+ C.foo() : f = 1;
+ const C.bar();
+}
+''', r'''
+class C {
+ final int f;
+ C.foo() : f = 2;
+ const C.bar();
+}
+''');
+ }
+
+ test_class_constructor_parameters_add() {
+ assertNotSameSignature(r'''
+class C {
+ C(int a);
+}
+''', r'''
+class C {
+ C(int a, int b);
+}
+''');
+ }
+
+ test_class_constructor_parameters_remove() {
+ assertNotSameSignature(r'''
+class C {
+ C(int a, int b);
+}
+''', r'''
+class C {
+ C(int a);
+}
+''');
+ }
+
+ test_class_constructor_parameters_rename() {
+ assertNotSameSignature(r'''
+class C {
+ C(int a);
+}
+''', r'''
+class C {
+ C(int b);
+}
+''');
+ }
+
+ test_class_constructor_parameters_type() {
+ assertNotSameSignature(r'''
+class C {
+ C(int p);
+}
+''', r'''
+class C {
+ C(double p);
+}
+''');
+ }
+
+ test_class_extends() {
+ assertNotSameSignature(r'''
+class A {}
+class B {}
+''', r'''
+class A {}
+class B extends A {}
+''');
+ }
+
+ test_class_field_withoutType() {
+ assertNotSameSignature(r'''
+class C {
+ var a = 1;
+}
+''', r'''
+class C {
+ var a = 2;
+}
+''');
+ }
+
+ test_class_field_withoutType2() {
+ assertNotSameSignature(r'''
+class C {
+ var a = 1, b = 2, c, d = 4;
+}
+''', r'''
+class C {
+ var a = 1, b, c = 3, d = 4;
+}
+''');
+ }
+
+ test_class_field_withType() {
+ assertSameSignature(r'''
+class C {
+ int a = 1, b, c = 3;
+}
+''', r'''
+class C {
+ int a = 0, b = 2, c;
+}
+''');
+ }
+
+ test_class_field_withType_const() {
+ assertNotSameSignature(r'''
+class C {
+ static const int a = 1;
+}
+''', r'''
+class C {
+ static const int a = 2;
+}
+''');
+ }
+
+ test_class_field_withType_final_hasConstConstructor() {
+ assertNotSameSignature(r'''
+class C {
+ final int a = 1;
+ const C();
+}
+''', r'''
+class C {
+ final int a = 2;
+ const C();
+}
+''');
+ }
+
+ test_class_field_withType_final_noConstConstructor() {
+ assertSameSignature(r'''
+class C {
+ final int a = 1;
+}
+''', r'''
+class C {
+ final int a = 2;
+}
+''');
+ }
+
+ test_class_field_withType_hasConstConstructor() {
+ assertSameSignature(r'''
+class C {
+ int a = 1;
+ const C();
+}
+''', r'''
+class C {
+ int a = 2;
+ const C();
+}
+''');
+ }
+
+ test_class_field_withType_static_final_hasConstConstructor() {
+ assertSameSignature(r'''
+class C {
+ static final int a = 1;
+ const C();
+}
+''', r'''
+class C {
+ static final int a = 2;
+ const C();
+}
+''');
+ }
+
+ test_class_field_withType_static_hasConstConstructor() {
+ assertSameSignature(r'''
+class C {
+ static int a = 1;
+ const C();
+}
+''', r'''
+class C {
+ static int a = 2;
+ const C();
+}
+''');
+ }
+
+ test_class_implements() {
+ assertNotSameSignature(r'''
+class A {}
+class B {}
+''', r'''
+class A {}
+class B implements A {}
+''');
+ }
+
+ test_class_method_annotation() {
+ assertNotSameSignature(r'''
+const a = 0;
+
+class C {
+ void foo() {}
+}
+''', r'''
+const a = 0;
+
+class C {
+ @a
+ void foo() {}
+}
+''');
+ }
+
+ test_class_method_body_async_to_sync() {
+ assertSameSignature(r'''
+class C {
+ Future foo() async {}
+}
+''', r'''
+class C {
+ Future foo() {}
+}
+''');
+ }
+
+ test_class_method_body_block() {
+ assertSameSignature(r'''
+class C {
+ int foo() {
+ return 1;
+ }
+}
+''', r'''
+class C {
+ int foo() {
+ return 2;
+ }
+}
+''');
+ }
+
+ test_class_method_body_block_to_expression() {
+ assertSameSignature(r'''
+class C {
+ int foo() {
+ return 1;
+ }
+}
+''', r'''
+class C {
+ int foo() => 2;
+}
+''');
+ }
+
+ test_class_method_body_empty_to_block() {
+ assertSameSignature(r'''
+class C {
+ int foo();
+}
+''', r'''
+class C {
+ int foo() {
+ var v = 0;
+ }
+}
+''');
+ }
+
+ test_class_method_body_expression() {
+ assertSameSignature(r'''
+class C {
+ int foo() => 1;
+}
+''', r'''
+class C {
+ int foo() => 2;
+}
+''');
+ }
+
+ test_class_method_body_sync_to_async() {
+ assertSameSignature(r'''
+class C {
+ Future foo() {}
+}
+''', r'''
+class C {
+ Future foo() async {}
+}
+''');
+ }
+
+ test_class_method_getter_body_block_to_expression() {
+ assertSameSignature(r'''
+class C {
+ int get foo {
+ return 1;
+ }
+}
+''', r'''
+class C {
+ int get foo => 2;
+}
+''');
+ }
+
+ test_class_method_getter_body_empty_to_expression() {
+ assertSameSignature(r'''
+class C {
+ int get foo;
+}
+''', r'''
+class C {
+ int get foo => 2;
+}
+''');
+ }
+
+ test_class_method_parameters_add() {
+ assertNotSameSignature(r'''
+class C {
+ foo(int a) {}
+}
+''', r'''
+class C {
+ foo(int a, int b) {}
+}
+''');
+ }
+
+ test_class_method_parameters_remove() {
+ assertNotSameSignature(r'''
+class C {
+ foo(int a, int b) {}
+}
+''', r'''
+class C {
+ foo(int a) {}
+}
+''');
+ }
+
+ test_class_method_parameters_rename() {
+ assertNotSameSignature(r'''
+class C {
+ void foo(int a) {}
+}
+''', r'''
+class C {
+ void foo(int b) {}
+}
+''');
+ }
+
+ test_class_method_parameters_type() {
+ assertNotSameSignature(r'''
+class C {
+ void foo(int p) {}
+}
+''', r'''
+class C {
+ void foo(double p) {}
+}
+''');
+ }
+
+ test_class_method_returnType() {
+ assertNotSameSignature(r'''
+class C {
+ int foo() => 0;
+}
+''', r'''
+class C {
+ num foo() => 0;
+}
+''');
+ }
+
+ test_class_method_typeParameters_add() async {
+ assertNotSameSignature(r'''
+class C {
+ void foo() {}
+}
+''', r'''
+class C {
+ void foo<T>() {}
+}
+''');
+ }
+
+ test_class_method_typeParameters_remove() {
+ assertNotSameSignature(r'''
+class C {
+ void foo<T>() {}
+}
+''', r'''
+class C {
+ void foo() {}
+}
+''');
+ }
+
+ test_class_method_typeParameters_rename() {
+ assertNotSameSignature(r'''
+class C {
+ void foo<T>() {}
+}
+''', r'''
+class C {
+ void foo<U>() {}
+}
+''');
+ }
+
+ test_class_modifier() {
+ assertNotSameSignature(r'''
+class C {}
+''', r'''
+abstract class C {}
+''');
+ }
+
+ test_class_with() {
+ assertNotSameSignature(r'''
+class A {}
+class B {}
+class C extends A {}
+''', r'''
+class A {}
+class B {}
+class C extends A with B {}
+''');
+ }
+
+ test_commentAdd() {
+ assertSameSignature(r'''
+var a = 1;
+var b = 2;
+var c = 3;
+''', r'''
+var a = 1; // comment
+
+/// comment 1
+/// comment 2
+var b = 2;
+
+/**
+ * Comment
+ */
+var c = 3;
+''');
+ }
+
+ test_commentRemove() {
+ assertSameSignature(r'''
+var a = 1; // comment
+
+/// comment 1
+/// comment 2
+var b = 2;
+
+/**
+ * Comment
+ */
+var c = 3;
+''', r'''
+var a = 1;
+var b = 2;
+var c = 3;
+''');
+ }
+
+ test_function_annotation() {
+ assertNotSameSignature(r'''
+const a = 0;
+
+void foo() {}
+''', r'''
+const a = 0;
+
+@a
+void foo() {}
+''');
+ }
+
+ test_function_body_async_to_sync() {
+ assertSameSignature(r'''
+Future foo() async {}
+''', r'''
+Future foo() {}
+''');
+ }
+
+ test_function_body_block() {
+ assertSameSignature(r'''
+int foo() {
+ return 1;
+}
+''', r'''
+int foo() {
+ return 2;
+}
+''');
+ }
+
+ test_function_body_block_to_expression() {
+ assertSameSignature(r'''
+int foo() {
+ return 1;
+}
+''', r'''
+int foo() => 2;
+''');
+ }
+
+ test_function_body_expression() {
+ assertSameSignature(r'''
+int foo() => 1;
+''', r'''
+int foo() => 2;
+''');
+ }
+
+ test_function_body_sync_to_async() {
+ assertSameSignature(r'''
+Future foo() {}
+''', r'''
+Future foo() async {}
+''');
+ }
+
+ test_function_getter_block_to_expression() {
+ assertSameSignature(r'''
+int get foo {
+ return 1;
+}
+''', r'''
+int get foo => 2;
+''');
+ }
+
+ test_function_parameters_rename() {
+ assertNotSameSignature(r'''
+void foo(int a) {}
+''', r'''
+void foo(int b) {}
+''');
+ }
+
+ test_function_parameters_type() {
+ assertNotSameSignature(r'''
+void foo(int p) {}
+''', r'''
+void foo(double p) {}
+''');
+ }
+
+ test_function_returnType() {
+ assertNotSameSignature(r'''
+int foo() => 0;
+''', r'''
+num foo() => 0;
+''');
+ }
+
+ test_function_typeParameters_add() {
+ assertNotSameSignature(r'''
+void foo() {}
+''', r'''
+void foo<T>() {}
+''');
+ }
+
+ test_function_typeParameters_remove() {
+ assertNotSameSignature(r'''
+void foo<T>() {}
+''', r'''
+void foo() {}
+''');
+ }
+
+ test_function_typeParameters_rename() {
+ assertNotSameSignature(r'''
+void foo<T>() {}
+''', r'''
+void foo<U>() {}
+''');
+ }
+
+ test_issue34850() {
+ assertNotSameSignature(r'''
+foo
+Future<List<int>> bar() {}
+''', r'''
+foo
+Future<List<int>> bar(int x) {}
+''');
+ }
+
+ test_mixin_field_withoutType() {
+ assertNotSameSignature(r'''
+mixin M {
+ var a = 1;
+}
+''', r'''
+mixin M {
+ var a = 2;
+}
+''');
+ }
+
+ test_mixin_field_withType() {
+ assertSameSignature(r'''
+mixin M {
+ int a = 1, b, c = 3;
+}
+''', r'''
+mixin M {
+ int a = 0, b = 2, c;
+}
+''');
+ }
+
+ test_mixin_implements() {
+ assertNotSameSignature(r'''
+class A {}
+mixin M {}
+''', r'''
+class A {}
+mixin M implements A {}
+''');
+ }
+
+ test_mixin_method_body_block() {
+ assertSameSignature(r'''
+mixin M {
+ int foo() {
+ return 1;
+ }
+}
+''', r'''
+mixin M {
+ int foo() {
+ return 2;
+ }
+}
+''');
+ }
+
+ test_mixin_method_body_expression() {
+ assertSameSignature(r'''
+mixin M {
+ int foo() => 1;
+}
+''', r'''
+mixin M {
+ int foo() => 2;
+}
+''');
+ }
+
+ test_mixin_on() {
+ assertNotSameSignature(r'''
+class A {}
+mixin M {}
+''', r'''
+class A {}
+mixin M on A {}
+''');
+ }
+
+ test_topLevelVariable_withoutType() {
+ assertNotSameSignature(r'''
+var a = 1;
+''', r'''
+var a = 2;
+''');
+ }
+
+ test_topLevelVariable_withoutType2() {
+ assertNotSameSignature(r'''
+var a = 1, b = 2, c, d = 4;;
+''', r'''
+var a = 1, b, c = 3, d = 4;;
+''');
+ }
+
+ test_topLevelVariable_withType() {
+ assertSameSignature(r'''
+int a = 1, b, c = 3;
+''', r'''
+int a = 0, b = 2, c;
+''');
+ }
+
+ test_topLevelVariable_withType_const() {
+ assertNotSameSignature(r'''
+const int a = 1;
+''', r'''
+const int a = 2;
+''');
+ }
+
+ test_topLevelVariable_withType_final() {
+ assertSameSignature(r'''
+final int a = 1;
+''', r'''
+final int a = 2;
+''');
+ }
+
+ test_typedef_generic_parameters_type() {
+ assertNotSameSignature(r'''
+typedef F = void Function(int);
+''', r'''
+typedef F = void Function(double);
+''');
+ }
+}
