Add wrapped versions of element classes.
These new classes are in lib/src to discourage them from being widely
used. The intention is to use them in angular_analyzer_plugin, so
that it can extend the wrapper classes rather than implement the
element classes directly. This will ensure that
angular_analyzer_plugin doesn't break when new methods are added to
element classes.
Change-Id: I33d82e4534691f546fcabc7b9d6c1da0258a5fc0
Reviewed-on: https://dart-review.googlesource.com/70020
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Reviewed-by: Mike Fairhurst <mfairhurst@google.com>
Commit-Queue: Paul Berry <paulberry@google.com>
diff --git a/pkg/analyzer/lib/src/dart/element/wrapped.dart b/pkg/analyzer/lib/src/dart/element/wrapped.dart
new file mode 100644
index 0000000..88291aa
--- /dev/null
+++ b/pkg/analyzer/lib/src/dart/element/wrapped.dart
@@ -0,0 +1,591 @@
+// Copyright (c) 2018, 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' hide Directive;
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/dart/resolver/scope.dart';
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
+import 'package:analyzer/src/generated/java_engine.dart';
+import 'package:analyzer/src/generated/source.dart';
+
+/// Implementation of [CompilationUnitElement] that wraps a
+/// [CompilationUnitElement] and defers all method calls to it.
+///
+/// This is intended to be used by the rare clients that must reimplement
+/// [CompilationUnitElement], so that they won't be broken if new methods are
+/// added.
+class WrappedCompilationUnitElement implements CompilationUnitElement {
+ final CompilationUnitElement wrappedUnit;
+
+ WrappedCompilationUnitElement(this.wrappedUnit);
+
+ @override
+ List<PropertyAccessorElement> get accessors => wrappedUnit.accessors;
+
+ @override
+ AnalysisContext get context => wrappedUnit.context;
+
+ @override
+ String get displayName => wrappedUnit.displayName;
+
+ @override
+ String get documentationComment => wrappedUnit.documentationComment;
+
+ @override
+ LibraryElement get enclosingElement => wrappedUnit.enclosingElement;
+
+ @override
+ List<ClassElement> get enums => wrappedUnit.enums;
+
+ @override
+ List<FunctionElement> get functions => wrappedUnit.functions;
+
+ @override
+ List<FunctionTypeAliasElement> get functionTypeAliases =>
+ wrappedUnit.functionTypeAliases;
+
+ @override
+ bool get hasAlwaysThrows => wrappedUnit.hasAlwaysThrows;
+
+ @override
+ bool get hasDeprecated => wrappedUnit.hasDeprecated;
+
+ @override
+ bool get hasFactory => wrappedUnit.hasFactory;
+
+ @override
+ bool get hasIsTest => wrappedUnit.hasIsTest;
+
+ @override
+ bool get hasIsTestGroup => wrappedUnit.hasIsTestGroup;
+
+ @override
+ bool get hasJS => wrappedUnit.hasJS;
+
+ @override
+ bool get hasLoadLibraryFunction => wrappedUnit.hasLoadLibraryFunction;
+
+ @override
+ bool get hasOverride => wrappedUnit.hasOverride;
+
+ @override
+ bool get hasProtected => wrappedUnit.hasProtected;
+
+ @override
+ bool get hasRequired => wrappedUnit.hasRequired;
+
+ @override
+ bool get hasVisibleForTemplate => wrappedUnit.hasVisibleForTemplate;
+
+ @override
+ bool get hasVisibleForTesting => wrappedUnit.hasVisibleForTesting;
+
+ @override
+ int get id => wrappedUnit.id;
+
+ @override
+ bool get isAlwaysThrows => hasAlwaysThrows;
+
+ @override
+ bool get isDeprecated => hasDeprecated;
+
+ @override
+ bool get isFactory => hasFactory;
+
+ @override
+ bool get isJS => hasJS;
+
+ @override
+ bool get isOverride => hasOverride;
+
+ @override
+ bool get isPrivate => wrappedUnit.isPrivate;
+
+ @override
+ bool get isProtected => hasProtected;
+
+ @override
+ bool get isPublic => wrappedUnit.isPublic;
+
+ @override
+ bool get isRequired => hasRequired;
+
+ @override
+ bool get isSynthetic => wrappedUnit.isSynthetic;
+
+ @override
+ bool get isVisibleForTesting => hasVisibleForTesting;
+
+ @override
+ ElementKind get kind => wrappedUnit.kind;
+
+ @override
+ LibraryElement get library => wrappedUnit.library;
+
+ @override
+ Source get librarySource => wrappedUnit.librarySource;
+
+ @override
+ LineInfo get lineInfo => wrappedUnit.lineInfo;
+
+ @override
+ ElementLocation get location => wrappedUnit.location;
+
+ @override
+ List<ElementAnnotation> get metadata => wrappedUnit.metadata;
+
+ @override
+ String get name => wrappedUnit.name;
+
+ @override
+ int get nameLength => wrappedUnit.nameLength;
+
+ @override
+ int get nameOffset => wrappedUnit.nameOffset;
+
+ @override
+ Source get source => wrappedUnit.source;
+
+ @override
+ List<TopLevelVariableElement> get topLevelVariables =>
+ wrappedUnit.topLevelVariables;
+
+ @override
+ List<ClassElement> get types => wrappedUnit.types;
+
+ @override
+ CompilationUnit get unit => wrappedUnit.unit;
+
+ @override
+ String get uri => wrappedUnit.uri;
+
+ @override
+ int get uriEnd => wrappedUnit.uriEnd;
+
+ @override
+ int get uriOffset => wrappedUnit.uriOffset;
+
+ @override
+ T accept<T>(ElementVisitor<T> visitor) => wrappedUnit.accept(visitor);
+
+ @override
+ String computeDocumentationComment() => wrappedUnit
+ .computeDocumentationComment(); // ignore: deprecated_member_use
+
+ @override
+ CompilationUnit computeNode() => wrappedUnit.computeNode();
+
+ @override
+ E getAncestor<E extends Element>(Predicate<Element> predicate) =>
+ wrappedUnit.getAncestor(predicate);
+
+ @override
+ ClassElement getEnum(String name) => wrappedUnit.getEnum(name);
+
+ @override
+ String getExtendedDisplayName(String shortName) =>
+ wrappedUnit.getExtendedDisplayName(shortName);
+
+ @override
+ ClassElement getType(String className) => wrappedUnit.getType(className);
+
+ @override
+ bool isAccessibleIn(LibraryElement library) =>
+ wrappedUnit.isAccessibleIn(library);
+
+ @override
+ void visitChildren(ElementVisitor visitor) =>
+ wrappedUnit.visitChildren(visitor);
+}
+
+/// Implementation of [ImportElement] that wraps an [ImportElement] and defers
+/// all method calls to it.
+///
+/// This is intended to be used by the rare clients that must reimplement
+/// [ImportElement], so that they won't be broken if new methods are added.
+class WrappedImportElement implements ImportElement {
+ final ImportElement wrappedImport;
+
+ WrappedImportElement(this.wrappedImport);
+
+ @override
+ List<NamespaceCombinator> get combinators => wrappedImport.combinators;
+
+ @override
+ AnalysisContext get context => wrappedImport.context;
+
+ @override
+ String get displayName => wrappedImport.displayName;
+
+ @override
+ String get documentationComment => wrappedImport.documentationComment;
+
+ @override
+ LibraryElement get enclosingElement => wrappedImport.enclosingElement;
+
+ @override
+ bool get hasAlwaysThrows => wrappedImport.hasAlwaysThrows;
+
+ @override
+ bool get hasDeprecated => wrappedImport.hasDeprecated;
+
+ @override
+ bool get hasFactory => wrappedImport.hasFactory;
+
+ @override
+ bool get hasIsTest => wrappedImport.hasIsTest;
+
+ @override
+ bool get hasIsTestGroup => wrappedImport.hasIsTestGroup;
+
+ @override
+ bool get hasJS => wrappedImport.hasJS;
+
+ @override
+ bool get hasOverride => wrappedImport.hasOverride;
+
+ @override
+ bool get hasProtected => wrappedImport.hasProtected;
+
+ @override
+ bool get hasRequired => wrappedImport.hasRequired;
+
+ @override
+ bool get hasVisibleForTemplate => wrappedImport.hasVisibleForTemplate;
+
+ @override
+ bool get hasVisibleForTesting => wrappedImport.hasVisibleForTesting;
+
+ @override
+ int get id => wrappedImport.id;
+
+ @override
+ LibraryElement get importedLibrary => wrappedImport.importedLibrary;
+
+ @override
+ bool get isAlwaysThrows => hasAlwaysThrows;
+
+ @override
+ bool get isDeferred => wrappedImport.isDeferred;
+
+ @override
+ bool get isDeprecated => hasDeprecated;
+
+ @override
+ bool get isFactory => hasFactory;
+
+ @override
+ bool get isJS => hasJS;
+
+ @override
+ bool get isOverride => hasOverride;
+
+ @override
+ bool get isPrivate => wrappedImport.isPrivate;
+
+ @override
+ bool get isProtected => hasProtected;
+
+ @override
+ bool get isPublic => wrappedImport.isPublic;
+
+ @override
+ bool get isRequired => hasRequired;
+
+ @override
+ bool get isSynthetic => wrappedImport.isSynthetic;
+
+ @override
+ bool get isVisibleForTesting => hasVisibleForTesting;
+
+ @override
+ ElementKind get kind => wrappedImport.kind;
+
+ @override
+ LibraryElement get library => wrappedImport.library;
+
+ @override
+ Source get librarySource => wrappedImport.librarySource;
+
+ @override
+ ElementLocation get location => wrappedImport.location;
+
+ @override
+ List<ElementAnnotation> get metadata => wrappedImport.metadata;
+
+ @override
+ String get name => wrappedImport.name;
+
+ @override
+ int get nameLength => wrappedImport.nameLength;
+
+ @override
+ int get nameOffset => wrappedImport.nameOffset;
+
+ @override
+ Namespace get namespace => wrappedImport.namespace;
+
+ @override
+ PrefixElement get prefix => wrappedImport.prefix;
+
+ @override
+ int get prefixOffset => wrappedImport.prefixOffset;
+
+ @override
+ Source get source => wrappedImport.source;
+
+ @override
+ CompilationUnit get unit => wrappedImport.unit;
+
+ @override
+ String get uri => wrappedImport.uri;
+
+ @override
+ int get uriEnd => wrappedImport.uriEnd;
+
+ @override
+ int get uriOffset => wrappedImport.uriOffset;
+
+ @override
+ T accept<T>(ElementVisitor<T> visitor) => wrappedImport.accept(visitor);
+
+ @override
+ String computeDocumentationComment() => wrappedImport
+ .computeDocumentationComment(); // ignore: deprecated_member_use
+
+ @override
+ AstNode computeNode() => wrappedImport.computeNode();
+
+ @override
+ E getAncestor<E extends Element>(Predicate<Element> predicate) =>
+ wrappedImport.getAncestor(predicate);
+
+ @override
+ String getExtendedDisplayName(String shortName) =>
+ wrappedImport.getExtendedDisplayName(shortName);
+
+ @override
+ bool isAccessibleIn(LibraryElement library) =>
+ wrappedImport.isAccessibleIn(library);
+
+ @override
+ void visitChildren(ElementVisitor visitor) =>
+ wrappedImport.visitChildren(visitor);
+}
+
+/// Implementation of [LibraryElement] that wraps a [LibraryElement] and defers
+/// all method calls to it.
+///
+/// This is intended to be used by the rare clients that must reimplement
+/// [LibraryElement], so that they won't be broken if new methods are added.
+class WrappedLibraryElement implements LibraryElement {
+ final LibraryElement wrappedLib;
+
+ WrappedLibraryElement(this.wrappedLib);
+
+ @override
+ AnalysisContext get context => wrappedLib.context;
+
+ @override
+ CompilationUnitElement get definingCompilationUnit =>
+ wrappedLib.definingCompilationUnit;
+
+ @override
+ String get displayName => wrappedLib.displayName;
+
+ @override
+ String get documentationComment => wrappedLib.documentationComment;
+
+ @override
+ Element get enclosingElement => wrappedLib.enclosingElement;
+
+ @override
+ FunctionElement get entryPoint => wrappedLib.entryPoint;
+
+ @override
+ List<LibraryElement> get exportedLibraries => wrappedLib.exportedLibraries;
+
+ @override
+ Namespace get exportNamespace => wrappedLib.exportNamespace;
+
+ @override
+ List<ExportElement> get exports => wrappedLib.exports;
+
+ @override
+ bool get hasAlwaysThrows => wrappedLib.hasAlwaysThrows;
+
+ @override
+ bool get hasDeprecated => wrappedLib.hasDeprecated;
+
+ @override
+ bool get hasExtUri => wrappedLib.hasExtUri;
+
+ @override
+ bool get hasFactory => wrappedLib.hasFactory;
+
+ @override
+ bool get hasIsTest => wrappedLib.hasIsTest;
+
+ @override
+ bool get hasIsTestGroup => wrappedLib.hasIsTestGroup;
+
+ @override
+ bool get hasJS => wrappedLib.hasJS;
+
+ @override
+ bool get hasLoadLibraryFunction => wrappedLib.hasLoadLibraryFunction;
+
+ @override
+ bool get hasOverride => wrappedLib.hasOverride;
+
+ @override
+ bool get hasProtected => wrappedLib.hasProtected;
+
+ @override
+ bool get hasRequired => wrappedLib.hasRequired;
+
+ @override
+ bool get hasVisibleForTemplate => wrappedLib.hasVisibleForTemplate;
+
+ @override
+ bool get hasVisibleForTesting => wrappedLib.hasVisibleForTesting;
+
+ @override
+ int get id => wrappedLib.id;
+
+ @override
+ String get identifier => wrappedLib.identifier;
+
+ @override
+ List<LibraryElement> get importedLibraries => wrappedLib.importedLibraries;
+
+ @override
+ List<ImportElement> get imports => wrappedLib.imports;
+
+ @override
+ bool get isAlwaysThrows => hasAlwaysThrows;
+
+ @override
+ bool get isBrowserApplication => wrappedLib.isBrowserApplication;
+
+ @override
+ bool get isDartAsync => wrappedLib.isDartAsync;
+
+ @override
+ bool get isDartCore => wrappedLib.isDartCore;
+
+ @override
+ bool get isDeprecated => hasDeprecated;
+
+ @override
+ bool get isFactory => hasFactory;
+
+ @override
+ bool get isInSdk => wrappedLib.isInSdk;
+
+ @override
+ bool get isJS => hasJS;
+
+ @override
+ bool get isOverride => hasOverride;
+
+ @override
+ bool get isPrivate => wrappedLib.isPrivate;
+
+ @override
+ bool get isProtected => hasProtected;
+
+ @override
+ bool get isPublic => wrappedLib.isPublic;
+
+ @override
+ bool get isRequired => hasRequired;
+
+ @override
+ bool get isSynthetic => wrappedLib.isSynthetic;
+
+ @override
+ bool get isVisibleForTesting => hasVisibleForTesting;
+
+ @override
+ ElementKind get kind => wrappedLib.kind;
+
+ @override
+ LibraryElement get library => wrappedLib.library;
+
+ @override
+ List<LibraryElement> get libraryCycle => wrappedLib.libraryCycle;
+
+ @override
+ Source get librarySource => wrappedLib.librarySource;
+
+ @override
+ FunctionElement get loadLibraryFunction => wrappedLib.loadLibraryFunction;
+
+ @override
+ ElementLocation get location => wrappedLib.location;
+
+ @override
+ List<ElementAnnotation> get metadata => wrappedLib.metadata;
+
+ @override
+ String get name => wrappedLib.name;
+
+ @override
+ int get nameLength => wrappedLib.nameLength;
+
+ @override
+ int get nameOffset => wrappedLib.nameOffset;
+
+ @override
+ List<CompilationUnitElement> get parts => wrappedLib.parts;
+
+ @override
+ List<PrefixElement> get prefixes => wrappedLib.prefixes;
+
+ @override
+ Namespace get publicNamespace => wrappedLib.publicNamespace;
+
+ @override
+ Source get source => wrappedLib.source;
+
+ @override
+ CompilationUnit get unit => wrappedLib.unit;
+
+ @override
+ List<CompilationUnitElement> get units => wrappedLib.units;
+
+ @override
+ T accept<T>(ElementVisitor<T> visitor) => wrappedLib.accept(visitor);
+
+ @override
+ String computeDocumentationComment() =>
+ wrappedLib.computeDocumentationComment(); // ignore: deprecated_member_use
+
+ @override
+ AstNode computeNode() => wrappedLib.computeNode();
+
+ @override
+ E getAncestor<E extends Element>(Predicate<Element> predicate) =>
+ wrappedLib.getAncestor(predicate);
+
+ @override
+ String getExtendedDisplayName(String shortName) =>
+ wrappedLib.getExtendedDisplayName(shortName);
+
+ @override
+ List<ImportElement> getImportsWithPrefix(PrefixElement prefix) =>
+ wrappedLib.getImportsWithPrefix(prefix);
+
+ @override
+ ClassElement getType(String className) => wrappedLib.getType(className);
+
+ @override
+ bool isAccessibleIn(LibraryElement library) =>
+ wrappedLib.isAccessibleIn(library);
+
+ @override
+ void visitChildren(ElementVisitor visitor) =>
+ wrappedLib.visitChildren(visitor);
+}
