Add support for the "external" keyword to summaries.

pkg/analyzer/test/src/summary/summary_test.dart

 // Copyright (c) 2015, 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 analyzer.test.src.summary.summary_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 769 matching lines @@
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].bound, isNull);
   }
 
   test_constructor() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.kind, UnlinkedExecutableKind.constructor);
     expect(executable.hasImplicitReturnType, isFalse);
+    expect(executable.isExternal, isFalse);
   }
 
   test_constructor_anonymous() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.name, isEmpty);
   }
 
   test_constructor_const() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { const C(); }').executables);
     expect(executable.isConst, isTrue);
+    expect(executable.isExternal, isFalse);
+  }
+
+  test_constructor_const_external() {
+    UnlinkedExecutable executable = findExecutable('',
+        executables:
+            serializeClassText('class C { external const C(); }').executables);
+    expect(executable.isConst, isTrue);
+    expect(executable.isExternal, isTrue);
+  }
+
+  test_constructor_external() {
+    UnlinkedExecutable executable = findExecutable('',
+        executables:
+            serializeClassText('class C { external C(); }').executables);
+    expect(executable.isExternal, isTrue);
   }
 
   test_constructor_factory() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { factory C() => null; }').executables);
     expect(executable.isFactory, isTrue);
   }
 
   test_constructor_implicit() {
@@ skipping 297 matching lines @@
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f() {} }').executables[0];
     expect(executable.isAbstract, isFalse);
   }
 
   test_executable_function() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
     checkDynamicTypeRef(executable.returnType);
+    expect(executable.isExternal, isFalse);
   }
 
   test_executable_function_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
+  test_executable_function_external() {
+    UnlinkedExecutable executable = serializeExecutableText('external f();');
+    expect(executable.isExternal, isTrue);
+  }
+
   test_executable_getter() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.hasImplicitReturnType, isFalse);
+    expect(executable.isExternal, isFalse);
     expect(findVariable('f'), isNull);
     expect(findExecutable('f='), isNull);
   }
 
+  test_executable_getter_external() {
+    UnlinkedExecutable executable =
+        serializeExecutableText('external int get f;');
+    expect(executable.isExternal, isTrue);
+  }
+
   test_executable_getter_type() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_getter_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('get f => 1;');
     checkDynamicTypeRef(executable.returnType);
     expect(executable.hasImplicitReturnType, isTrue);
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_member_function() {
     UnlinkedExecutable executable = findExecutable('f',
         executables: serializeClassText('class C { f() {} }').executables);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
+    expect(executable.isExternal, isFalse);
   }
 
   test_executable_member_function_explicit_return() {
     UnlinkedExecutable executable = findExecutable('f',
         executables:
             serializeClassText('class C { dynamic f() => null; }').executables);
     expect(executable.hasImplicitReturnType, isFalse);
   }
 
+  test_executable_member_function_external() {
+    UnlinkedExecutable executable = findExecutable('f',
+        executables:
+            serializeClassText('class C { external f(); }').executables);
+    expect(executable.isExternal, isTrue);
+  }
+
   test_executable_member_getter() {
     UnlinkedClass cls = serializeClassText('class C { int get f => 1; }');
     UnlinkedExecutable executable =
         findExecutable('f', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.hasImplicitReturnType, isFalse);
+    expect(executable.isExternal, isFalse);
     expect(findVariable('f', variables: cls.fields), isNull);
     expect(findExecutable('f=', executables: cls.executables), isNull);
   }
 
+  test_executable_member_getter_external() {
+    UnlinkedClass cls = serializeClassText('class C { external int get f; }');
+    UnlinkedExecutable executable =
+        findExecutable('f', executables: cls.executables, failIfAbsent: true);
+    expect(executable.isExternal, isTrue);
+  }
+
   test_executable_member_setter() {
     UnlinkedClass cls = serializeClassText('class C { void set f(value) {} }');
     UnlinkedExecutable executable =
         findExecutable('f=', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.setter);
     // For setters, hasImplicitReturnType is always false.
     expect(executable.hasImplicitReturnType, isFalse);
+    expect(executable.isExternal, isFalse);
     expect(findVariable('f', variables: cls.fields), isNull);
     expect(findExecutable('f', executables: cls.executables), isNull);
   }
 
+  test_executable_member_setter_external() {
+    UnlinkedClass cls =
+        serializeClassText('class C { external void set f(value); }');
+    UnlinkedExecutable executable =
+        findExecutable('f=', executables: cls.executables, failIfAbsent: true);
+    expect(executable.isExternal, isTrue);
+  }
+
   test_executable_member_setter_implicit_return() {
     UnlinkedClass cls = serializeClassText('class C { set f(value) {} }');
     UnlinkedExecutable executable =
         findExecutable('f=', executables: cls.executables, failIfAbsent: true);
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_name() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
@@ skipping 13 matching lines @@
         serializeClassText('class C { f() {} }').executables[0];
     expect(executable.isStatic, isFalse);
   }
 
   test_executable_non_static_top_level() {
     // Top level executables are considered non-static.
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.isStatic, isFalse);
   }
 
+  test_executable_operator() {
+    UnlinkedExecutable executable =
+        serializeClassText('class C { C operator+(C c) => null; }').executables[
+            0];
+    expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
+    expect(executable.name, '+');
+    expect(executable.hasImplicitReturnType, false);
+    expect(executable.isAbstract, false);
+    expect(executable.isConst, false);
+    expect(executable.isFactory, false);
+    expect(executable.isStatic, false);
+    expect(executable.parameters, hasLength(1));
+    checkTypeRef(executable.returnType, null, null, 'C');
+    expect(executable.typeParameters, isEmpty);
+    expect(executable.isExternal, false);
+  }
+
+  test_executable_operator_external() {
+    UnlinkedExecutable executable =
+        serializeClassText('class C { external C operator+(C c); }')
+            .executables[0];
+    expect(executable.isExternal, true);
+  }
+
   test_executable_operator_index() {
     UnlinkedExecutable executable =
         serializeClassText('class C { bool operator[](int i) => null; }')
             .executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
@@ skipping 137 matching lines @@
   test_executable_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('void f() {}');
     expect(executable.returnType, isNull);
   }
 
   test_executable_setter() {
     UnlinkedExecutable executable =
         serializeExecutableText('void set f(value) {}', 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.hasImplicitReturnType, isFalse);
+    expect(executable.isExternal, isFalse);
     expect(findVariable('f'), isNull);
     expect(findExecutable('f'), isNull);
   }
 
+  test_executable_setter_external() {
+    UnlinkedExecutable executable =
+        serializeExecutableText('external void set f(value);', 'f=');
+    expect(executable.isExternal, isTrue);
+  }
+
   test_executable_setter_implicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('set f(value) {}', 'f=');
     // For setters, hasImplicitReturnType is always false.
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_setter_type() {
     UnlinkedExecutable executable =
@@ skipping 630 matching lines @@
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 }