karlklose@google.com
5ac1789d6c
TBR=antonm@google.com Review URL: https://chromiumcodereview.appspot.com//10827442 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@11051 260f80e4-7a28-3924-810f-c04153c831b5
2536 lines
87 KiB
Dart
2536 lines
87 KiB
Dart
// Copyright (c) 2012, 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.
|
|
|
|
interface TreeElements {
|
|
Element operator[](Node node);
|
|
Selector getSelector(Send send);
|
|
Type getType(TypeAnnotation annotation);
|
|
}
|
|
|
|
class TreeElementMapping implements TreeElements {
|
|
Map<Node, Element> map;
|
|
Map<Node, Selector> selectors;
|
|
Map<TypeAnnotation, Type> types;
|
|
|
|
TreeElementMapping()
|
|
: map = new LinkedHashMap<Node, Element>(),
|
|
selectors = new LinkedHashMap<Node, Selector>(),
|
|
types = new LinkedHashMap<TypeAnnotation, Type>();
|
|
|
|
operator []=(Node node, Element element) => map[node] = element;
|
|
operator [](Node node) => map[node];
|
|
void remove(Node node) { map.remove(node); }
|
|
|
|
void setType(TypeAnnotation annotation, Type type) {
|
|
types[annotation] = type;
|
|
}
|
|
|
|
Type getType(TypeAnnotation annotation) => types[annotation];
|
|
|
|
void setSelector(Node node, Selector selector) {
|
|
selectors[node] = selector;
|
|
}
|
|
|
|
Selector getSelector(Node node) => selectors[node];
|
|
}
|
|
|
|
class ResolverTask extends CompilerTask {
|
|
ResolverTask(Compiler compiler) : super(compiler);
|
|
|
|
String get name() => 'Resolver';
|
|
|
|
TreeElements resolve(Element element) {
|
|
return measure(() {
|
|
ElementKind kind = element.kind;
|
|
if (kind === ElementKind.GENERATIVE_CONSTRUCTOR ||
|
|
kind === ElementKind.FUNCTION ||
|
|
kind === ElementKind.GETTER ||
|
|
kind === ElementKind.SETTER) {
|
|
return resolveMethodElement(element);
|
|
}
|
|
|
|
if (kind === ElementKind.FIELD) return resolveField(element);
|
|
|
|
if (kind === ElementKind.PARAMETER ||
|
|
kind === ElementKind.FIELD_PARAMETER) {
|
|
return resolveParameter(element);
|
|
}
|
|
|
|
compiler.unimplemented("resolve($element)",
|
|
node: element.parseNode(compiler));
|
|
});
|
|
}
|
|
|
|
SourceString getConstructorName(Send node) {
|
|
if (node.receiver !== null) {
|
|
return node.selector.asIdentifier().source;
|
|
} else {
|
|
return const SourceString('');
|
|
}
|
|
}
|
|
|
|
FunctionElement resolveConstructorRedirection(FunctionElement constructor) {
|
|
FunctionExpression node = constructor.parseNode(compiler);
|
|
// A synthetic constructor does not have a node.
|
|
if (node === null) return null;
|
|
if (node.initializers === null) return null;
|
|
Link<Node> initializers = node.initializers.nodes;
|
|
if (!initializers.isEmpty() &&
|
|
Initializers.isConstructorRedirect(initializers.head)) {
|
|
final ClassElement classElement = constructor.getEnclosingClass();
|
|
final SourceString constructorName =
|
|
getConstructorName(initializers.head);
|
|
final SourceString className = classElement.name;
|
|
return classElement.lookupConstructor(className, constructorName);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
void resolveRedirectingConstructor(InitializerResolver resolver,
|
|
Node node,
|
|
FunctionElement constructor,
|
|
FunctionElement redirection) {
|
|
Set<FunctionElement> seen = new Set<FunctionElement>();
|
|
seen.add(constructor);
|
|
while (redirection !== null) {
|
|
if (seen.contains(redirection)) {
|
|
resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
|
|
return;
|
|
}
|
|
seen.add(redirection);
|
|
redirection = resolveConstructorRedirection(redirection);
|
|
}
|
|
}
|
|
|
|
TreeElements resolveMethodElement(FunctionElement element) {
|
|
return compiler.withCurrentElement(element, () {
|
|
bool isConstructor = element.kind === ElementKind.GENERATIVE_CONSTRUCTOR;
|
|
TreeElements elements =
|
|
compiler.enqueuer.resolution.getCachedElements(element);
|
|
if (elements !== null) {
|
|
assert(isConstructor);
|
|
return elements;
|
|
}
|
|
FunctionExpression tree = element.parseNode(compiler);
|
|
if (isConstructor) {
|
|
resolveConstructorImplementation(element, tree);
|
|
}
|
|
ResolverVisitor visitor = new ResolverVisitor(compiler, element);
|
|
visitor.useElement(tree, element);
|
|
visitor.setupFunction(tree, element);
|
|
|
|
if (isConstructor) {
|
|
// Even if there is no initializer list we still have to do the
|
|
// resolution in case there is an implicit super constructor call.
|
|
InitializerResolver resolver = new InitializerResolver(visitor);
|
|
FunctionElement redirection =
|
|
resolver.resolveInitializers(element, tree);
|
|
if (redirection !== null) {
|
|
resolveRedirectingConstructor(resolver, tree, element, redirection);
|
|
}
|
|
} else if (tree.initializers != null) {
|
|
error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
|
|
}
|
|
visitBody(visitor, tree.body);
|
|
|
|
return visitor.mapping;
|
|
});
|
|
}
|
|
|
|
void visitBody(ResolverVisitor visitor, Statement body) {
|
|
visitor.visit(body);
|
|
}
|
|
|
|
void resolveConstructorImplementation(FunctionElement constructor,
|
|
FunctionExpression node) {
|
|
if (constructor.defaultImplementation !== constructor) return;
|
|
ClassElement intrface = constructor.getEnclosingClass();
|
|
if (!intrface.isInterface()) return;
|
|
Type defaultType = intrface.defaultClass;
|
|
if (defaultType === null) {
|
|
error(node, MessageKind.NO_DEFAULT_CLASS, [intrface.name]);
|
|
}
|
|
ClassElement defaultClass = defaultType.element;
|
|
defaultClass.ensureResolved(compiler);
|
|
assert(defaultClass.resolutionState == ClassElement.STATE_DONE);
|
|
assert(defaultClass.supertypeLoadState == ClassElement.STATE_DONE);
|
|
if (defaultClass.isInterface()) {
|
|
error(node, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
|
|
[defaultClass.name]);
|
|
}
|
|
// We have now established the following:
|
|
// [intrface] is an interface, let's say "MyInterface".
|
|
// [defaultClass] is a class, let's say "MyClass".
|
|
|
|
// If the default class implements the interface then we must use the
|
|
// default class' name. Otherwise we look for a factory with the name
|
|
// of the interface.
|
|
SourceString name;
|
|
if (defaultClass.implementsInterface(intrface)) {
|
|
// TODO(ahe): Don't use string replacement here.
|
|
name = new SourceString(constructor.name.slowToString().replaceFirst(
|
|
intrface.name.slowToString(),
|
|
defaultClass.name.slowToString()));
|
|
} else {
|
|
name = constructor.name;
|
|
}
|
|
constructor.defaultImplementation = defaultClass.lookupConstructor(name);
|
|
|
|
if (constructor.defaultImplementation === null) {
|
|
// We failed to find a constructor named either
|
|
// "MyInterface.name" or "MyClass.name".
|
|
error(node,
|
|
MessageKind.CANNOT_FIND_CONSTRUCTOR2,
|
|
[name, defaultClass.name]);
|
|
}
|
|
}
|
|
|
|
TreeElements resolveField(Element element) {
|
|
Node tree = element.parseNode(compiler);
|
|
ResolverVisitor visitor = new ResolverVisitor(compiler, element);
|
|
initializerDo(tree, visitor.visit);
|
|
return visitor.mapping;
|
|
}
|
|
|
|
TreeElements resolveParameter(Element element) {
|
|
Node tree = element.parseNode(compiler);
|
|
ResolverVisitor visitor =
|
|
new ResolverVisitor(compiler, element.enclosingElement);
|
|
initializerDo(tree, visitor.visit);
|
|
return visitor.mapping;
|
|
}
|
|
|
|
Type resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
|
|
if (annotation === null) return compiler.types.dynamicType;
|
|
ResolverVisitor visitor = new ResolverVisitor(compiler, element);
|
|
Type result = visitor.resolveTypeAnnotation(annotation);
|
|
if (result === null) {
|
|
// TODO(karklose): warning.
|
|
return compiler.types.dynamicType;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Load and resolve the supertypes of [cls].
|
|
*
|
|
* Warning: do not call this method directly. It should only be
|
|
* called by [resolveClass] and [ClassSupertypeResolver].
|
|
*/
|
|
void loadSupertypes(ClassElement cls, Node from) {
|
|
compiler.withCurrentElement(cls, () => measure(() {
|
|
if (cls.supertypeLoadState == ClassElement.STATE_DONE) return;
|
|
if (cls.supertypeLoadState == ClassElement.STATE_STARTED) {
|
|
compiler.reportMessage(
|
|
compiler.spanFromNode(from),
|
|
MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
|
|
api.Diagnostic.ERROR);
|
|
cls.supertypeLoadState = ClassElement.STATE_DONE;
|
|
cls.allSupertypes = const EmptyLink<Type>().prepend(
|
|
compiler.objectClass.computeType(compiler));
|
|
// TODO(ahe): We should also set cls.supertype here to avoid
|
|
// creating a malformed class hierarchy.
|
|
return;
|
|
}
|
|
cls.supertypeLoadState = ClassElement.STATE_STARTED;
|
|
compiler.withCurrentElement(cls, () {
|
|
// TODO(ahe): Cache the node in cls.
|
|
cls.parseNode(compiler).accept(new ClassSupertypeResolver(compiler,
|
|
cls));
|
|
if (cls.supertypeLoadState != ClassElement.STATE_DONE) {
|
|
cls.supertypeLoadState = ClassElement.STATE_DONE;
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Resolve the class [element].
|
|
*
|
|
* Before calling this method, [element] was constructed by the
|
|
* scanner and most fields are null or empty. This method fills in
|
|
* these fields and also ensure that the supertypes of [element] are
|
|
* resolved.
|
|
*
|
|
* Warning: Do not call this method directly. Instead use
|
|
* [:element.ensureResolved(compiler):].
|
|
*/
|
|
void resolveClass(ClassElement element) {
|
|
assert(element.resolutionState == ClassElement.STATE_NOT_STARTED);
|
|
element.resolutionState = ClassElement.STATE_STARTED;
|
|
compiler.withCurrentElement(element, () => measure(() {
|
|
ClassNode tree = element.parseNode(compiler);
|
|
loadSupertypes(element, tree);
|
|
|
|
ClassResolverVisitor visitor =
|
|
new ClassResolverVisitor(compiler, element);
|
|
visitor.visit(tree);
|
|
element.resolutionState = ClassElement.STATE_DONE;
|
|
}));
|
|
}
|
|
|
|
void checkMembers(ClassElement cls) {
|
|
if (cls === compiler.objectClass) return;
|
|
cls.forEachMember((holder, member) {
|
|
checkAbstractField(member);
|
|
checkValidOverride(member, cls.lookupSuperMember(member.name));
|
|
});
|
|
}
|
|
|
|
void checkAbstractField(Element member) {
|
|
if (member is !AbstractFieldElement) return;
|
|
if (member.getter === null) return;
|
|
if (member.setter === null) return;
|
|
int getterFlags = member.getter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
|
|
int setterFlags = member.setter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
|
|
if (getterFlags !== setterFlags) {
|
|
final mismatchedFlags =
|
|
new Modifiers.withFlags(null, getterFlags ^ setterFlags);
|
|
compiler.reportMessage(
|
|
compiler.spanFromElement(member.getter),
|
|
MessageKind.GETTER_MISMATCH.error([mismatchedFlags]),
|
|
api.Diagnostic.ERROR);
|
|
compiler.reportMessage(
|
|
compiler.spanFromElement(member.setter),
|
|
MessageKind.SETTER_MISMATCH.error([mismatchedFlags]),
|
|
api.Diagnostic.ERROR);
|
|
}
|
|
}
|
|
|
|
reportErrorWithContext(Element errorneousElement,
|
|
MessageKind errorMessage,
|
|
Element contextElement,
|
|
MessageKind contextMessage) {
|
|
compiler.reportMessage(
|
|
compiler.spanFromElement(errorneousElement),
|
|
errorMessage.error([contextElement.name,
|
|
contextElement.getEnclosingClass().name]),
|
|
api.Diagnostic.ERROR);
|
|
compiler.reportMessage(
|
|
compiler.spanFromElement(contextElement),
|
|
contextMessage.error(),
|
|
api.Diagnostic.INFO);
|
|
}
|
|
|
|
void checkValidOverride(Element member, Element superMember) {
|
|
if (superMember === null) return;
|
|
if (member.modifiers.isStatic()) {
|
|
reportErrorWithContext(
|
|
member, MessageKind.NO_STATIC_OVERRIDE,
|
|
superMember, MessageKind.NO_STATIC_OVERRIDE_CONT);
|
|
} else {
|
|
FunctionElement superFunction = superMember.asFunctionElement();
|
|
FunctionElement function = member.asFunctionElement();
|
|
if (superFunction === null || superFunction.isAccessor()) {
|
|
// Field or accessor in super.
|
|
if (function !== null && !function.isAccessor()) {
|
|
// But a plain method in this class.
|
|
reportErrorWithContext(
|
|
member, MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD,
|
|
superMember, MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT);
|
|
}
|
|
} else {
|
|
// Instance method in super.
|
|
if (function === null || function.isAccessor()) {
|
|
// But a field (or accessor) in this class.
|
|
reportErrorWithContext(
|
|
member, MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD,
|
|
superMember, MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT);
|
|
} else {
|
|
// Both are plain instance methods.
|
|
if (superFunction.requiredParameterCount(compiler) !=
|
|
function.requiredParameterCount(compiler)) {
|
|
reportErrorWithContext(
|
|
member,
|
|
MessageKind.BAD_ARITY_OVERRIDE,
|
|
superMember,
|
|
MessageKind.BAD_ARITY_OVERRIDE_CONT);
|
|
}
|
|
// TODO(ahe): Check optional parameters.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FunctionSignature resolveSignature(FunctionElement element) {
|
|
return compiler.withCurrentElement(element, () {
|
|
FunctionExpression node =
|
|
compiler.parser.measure(() => element.parseNode(compiler));
|
|
return measure(() => SignatureResolver.analyze(
|
|
compiler, node.parameters, node.returnType, element));
|
|
});
|
|
}
|
|
|
|
FunctionSignature resolveFunctionExpression(Element element,
|
|
FunctionExpression node) {
|
|
return measure(() => SignatureResolver.analyze(
|
|
compiler, node.parameters, node.returnType, element));
|
|
}
|
|
|
|
void resolveTypedef(TypedefElement element) {
|
|
if (element.isResolved || element.isBeingResolved) return;
|
|
element.isBeingResolved = true;
|
|
return compiler.withCurrentElement(element, () {
|
|
measure(() {
|
|
Typedef node =
|
|
compiler.parser.measure(() => element.parseNode(compiler));
|
|
TypedefResolverVisitor visitor =
|
|
new TypedefResolverVisitor(compiler, element);
|
|
visitor.visit(node);
|
|
|
|
element.isBeingResolved = false;
|
|
element.isResolved = true;
|
|
});
|
|
});
|
|
}
|
|
|
|
FunctionType computeFunctionType(Element element,
|
|
FunctionSignature signature) {
|
|
LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
|
|
for (Link<Element> link = signature.requiredParameters;
|
|
!link.isEmpty();
|
|
link = link.tail) {
|
|
parameterTypes.addLast(link.head.computeType(compiler));
|
|
// TODO(karlklose): optional parameters.
|
|
}
|
|
return new FunctionType(signature.returnType,
|
|
parameterTypes.toLink(),
|
|
element);
|
|
}
|
|
|
|
error(Node node, MessageKind kind, [arguments = const []]) {
|
|
ResolutionError message = new ResolutionError(kind, arguments);
|
|
compiler.reportError(node, message);
|
|
}
|
|
}
|
|
|
|
class InitializerResolver {
|
|
final ResolverVisitor visitor;
|
|
final Map<SourceString, Node> initialized;
|
|
Link<Node> initializers;
|
|
bool hasSuper;
|
|
|
|
InitializerResolver(this.visitor)
|
|
: initialized = new Map<SourceString, Node>(), hasSuper = false;
|
|
|
|
error(Node node, MessageKind kind, [arguments = const []]) {
|
|
visitor.error(node, kind, arguments);
|
|
}
|
|
|
|
warning(Node node, MessageKind kind, [arguments = const []]) {
|
|
visitor.warning(node, kind, arguments);
|
|
}
|
|
|
|
bool isFieldInitializer(SendSet node) {
|
|
if (node.selector.asIdentifier() == null) return false;
|
|
if (node.receiver == null) return true;
|
|
if (node.receiver.asIdentifier() == null) return false;
|
|
return node.receiver.asIdentifier().isThis();
|
|
}
|
|
|
|
void checkForDuplicateInitializers(SourceString name, Node init) {
|
|
if (initialized.containsKey(name)) {
|
|
error(init, MessageKind.DUPLICATE_INITIALIZER, [name]);
|
|
warning(initialized[name], MessageKind.ALREADY_INITIALIZED, [name]);
|
|
}
|
|
initialized[name] = init;
|
|
}
|
|
|
|
void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
|
|
// init is of the form [this.]field = value.
|
|
final Node selector = init.selector;
|
|
final SourceString name = selector.asIdentifier().source;
|
|
// Lookup target field.
|
|
Element target;
|
|
if (isFieldInitializer(init)) {
|
|
final ClassElement classElement = constructor.getEnclosingClass();
|
|
target = classElement.lookupLocalMember(name);
|
|
if (target === null) {
|
|
error(selector, MessageKind.CANNOT_RESOLVE, [name]);
|
|
} else if (target.kind != ElementKind.FIELD) {
|
|
error(selector, MessageKind.NOT_A_FIELD, [name]);
|
|
} else if (!target.isInstanceMember()) {
|
|
error(selector, MessageKind.INIT_STATIC_FIELD, [name]);
|
|
}
|
|
} else {
|
|
error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
|
|
}
|
|
visitor.useElement(init, target);
|
|
visitor.world.registerStaticUse(target);
|
|
checkForDuplicateInitializers(name, init);
|
|
// Resolve initializing value.
|
|
visitor.visitInStaticContext(init.arguments.head);
|
|
}
|
|
|
|
Element resolveSuperOrThisForSend(FunctionElement constructor,
|
|
FunctionExpression functionNode,
|
|
Send call) {
|
|
// Resolve the selector and the arguments.
|
|
ResolverTask resolver = visitor.compiler.resolver;
|
|
visitor.inStaticContext(() {
|
|
visitor.resolveSelector(call);
|
|
visitor.resolveArguments(call.argumentsNode);
|
|
});
|
|
Selector selector = visitor.mapping.getSelector(call);
|
|
bool isSuperCall = Initializers.isSuperConstructorCall(call);
|
|
SourceString constructorName = resolver.getConstructorName(call);
|
|
Element result = resolveSuperOrThis(
|
|
constructor, isSuperCall, false, constructorName, selector, call);
|
|
visitor.useElement(call, result);
|
|
visitor.world.registerStaticUse(result);
|
|
return result;
|
|
}
|
|
|
|
void resolveImplicitSuperConstructorSend(FunctionElement constructor,
|
|
FunctionExpression functionNode) {
|
|
// If the class has a super resolve the implicit super call.
|
|
ClassElement classElement = constructor.getEnclosingClass();
|
|
ClassElement superClass = classElement.superclass;
|
|
if (classElement != visitor.compiler.objectClass) {
|
|
assert(superClass !== null);
|
|
assert(superClass.resolutionState == ClassElement.STATE_DONE);
|
|
SourceString name = const SourceString('');
|
|
Selector call = new Selector.call(name, classElement.getLibrary(), 0);
|
|
var element = resolveSuperOrThis(constructor, true, true,
|
|
name, call, functionNode);
|
|
visitor.world.registerStaticUse(element);
|
|
}
|
|
}
|
|
|
|
Element resolveSuperOrThis(FunctionElement constructor,
|
|
bool isSuperCall,
|
|
bool isImplicitSuperCall,
|
|
SourceString constructorName,
|
|
Selector selector,
|
|
Node diagnosticNode) {
|
|
ClassElement lookupTarget = constructor.getEnclosingClass();
|
|
bool validTarget = true;
|
|
FunctionElement result;
|
|
if (isSuperCall) {
|
|
// Calculate correct lookup target and constructor name.
|
|
if (lookupTarget === visitor.compiler.objectClass) {
|
|
error(diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
|
|
} else {
|
|
lookupTarget = lookupTarget.supertype.element;
|
|
}
|
|
}
|
|
|
|
// Lookup constructor and try to match it to the selector.
|
|
ResolverTask resolver = visitor.compiler.resolver;
|
|
final SourceString className = lookupTarget.name;
|
|
result = lookupTarget.lookupConstructor(className, constructorName);
|
|
if (result === null || !result.isGenerativeConstructor()) {
|
|
String classNameString = className.slowToString();
|
|
String constructorNameString = constructorName.slowToString();
|
|
String name = (constructorName === const SourceString(''))
|
|
? classNameString
|
|
: "$classNameString.$constructorNameString";
|
|
MessageKind kind = isImplicitSuperCall
|
|
? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
|
|
: MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
|
|
error(diagnosticNode, kind, [name]);
|
|
} else {
|
|
if (!selector.applies(result, visitor.compiler)) {
|
|
MessageKind kind = isImplicitSuperCall
|
|
? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
|
|
: MessageKind.NO_MATCHING_CONSTRUCTOR;
|
|
error(diagnosticNode, kind);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
FunctionElement resolveRedirection(FunctionElement constructor,
|
|
FunctionExpression functionNode) {
|
|
if (functionNode.initializers === null) return null;
|
|
Link<Node> link = functionNode.initializers.nodes;
|
|
if (!link.isEmpty() && Initializers.isConstructorRedirect(link.head)) {
|
|
return resolveSuperOrThisForSend(constructor, functionNode, link.head);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Resolve all initializers of this constructor. In the case of a redirecting
|
|
* constructor, the resolved constructor's function element is returned.
|
|
*/
|
|
FunctionElement resolveInitializers(FunctionElement constructor,
|
|
FunctionExpression functionNode) {
|
|
// Keep track of all "this.param" parameters specified for constructor so
|
|
// that we can ensure that fields are initialized only once.
|
|
FunctionSignature functionParameters =
|
|
constructor.computeSignature(visitor.compiler);
|
|
functionParameters.forEachParameter((Element element) {
|
|
if (element.kind === ElementKind.FIELD_PARAMETER) {
|
|
checkForDuplicateInitializers(element.name,
|
|
element.parseNode(visitor.compiler));
|
|
}
|
|
});
|
|
|
|
if (functionNode.initializers === null) {
|
|
initializers = const EmptyLink<Node>();
|
|
} else {
|
|
initializers = functionNode.initializers.nodes;
|
|
}
|
|
FunctionElement result;
|
|
bool resolvedSuper = false;
|
|
for (Link<Node> link = initializers;
|
|
!link.isEmpty();
|
|
link = link.tail) {
|
|
if (link.head.asSendSet() != null) {
|
|
final SendSet init = link.head.asSendSet();
|
|
resolveFieldInitializer(constructor, init);
|
|
} else if (link.head.asSend() !== null) {
|
|
final Send call = link.head.asSend();
|
|
if (Initializers.isSuperConstructorCall(call)) {
|
|
if (resolvedSuper) {
|
|
error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
|
|
}
|
|
resolveSuperOrThisForSend(constructor, functionNode, call);
|
|
resolvedSuper = true;
|
|
} else if (Initializers.isConstructorRedirect(call)) {
|
|
// Check that there is no body (Language specification 7.5.1).
|
|
if (functionNode.hasBody()) {
|
|
error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
|
|
}
|
|
// Check that there are no other initializers.
|
|
if (!initializers.tail.isEmpty()) {
|
|
error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
|
|
}
|
|
return resolveSuperOrThisForSend(constructor, functionNode, call);
|
|
} else {
|
|
visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
|
|
return null;
|
|
}
|
|
} else {
|
|
error(link.head, MessageKind.INVALID_INITIALIZER);
|
|
}
|
|
}
|
|
if (!resolvedSuper) {
|
|
resolveImplicitSuperConstructorSend(constructor, functionNode);
|
|
}
|
|
return null; // If there was no redirection always return null.
|
|
}
|
|
}
|
|
|
|
class CommonResolverVisitor<R> extends AbstractVisitor<R> {
|
|
final Compiler compiler;
|
|
|
|
CommonResolverVisitor(Compiler this.compiler);
|
|
|
|
R visitNode(Node node) {
|
|
cancel(node,
|
|
'internal error: Unhandled node: ${node.getObjectDescription()}');
|
|
}
|
|
|
|
R visitEmptyStatement(Node node) => null;
|
|
|
|
/** Convenience method for visiting nodes that may be null. */
|
|
R visit(Node node) => (node == null) ? null : node.accept(this);
|
|
|
|
void error(Node node, MessageKind kind, [arguments = const []]) {
|
|
ResolutionError message = new ResolutionError(kind, arguments);
|
|
compiler.reportError(node, message);
|
|
}
|
|
|
|
void warning(Node node, MessageKind kind, [arguments = const []]) {
|
|
ResolutionWarning message = new ResolutionWarning(kind, arguments);
|
|
compiler.reportWarning(node, message);
|
|
}
|
|
|
|
void cancel(Node node, String message) {
|
|
compiler.cancel(message, node: node);
|
|
}
|
|
|
|
void internalError(Node node, String message) {
|
|
compiler.internalError(message, node: node);
|
|
}
|
|
|
|
void unimplemented(Node node, String message) {
|
|
compiler.unimplemented(message, node: node);
|
|
}
|
|
}
|
|
|
|
interface LabelScope {
|
|
LabelScope get outer();
|
|
LabelElement lookup(String label);
|
|
}
|
|
|
|
class LabeledStatementLabelScope implements LabelScope {
|
|
final LabelScope outer;
|
|
final Map<String, LabelElement> labels;
|
|
LabeledStatementLabelScope(this.outer, this.labels);
|
|
LabelElement lookup(String labelName) {
|
|
LabelElement label = labels[labelName];
|
|
if (label !== null) return label;
|
|
return outer.lookup(labelName);
|
|
}
|
|
}
|
|
|
|
class SwitchLabelScope implements LabelScope {
|
|
final LabelScope outer;
|
|
final Map<String, LabelElement> caseLabels;
|
|
|
|
SwitchLabelScope(this.outer, this.caseLabels);
|
|
|
|
LabelElement lookup(String labelName) {
|
|
LabelElement result = caseLabels[labelName];
|
|
if (result !== null) return result;
|
|
return outer.lookup(labelName);
|
|
}
|
|
}
|
|
|
|
class EmptyLabelScope implements LabelScope {
|
|
const EmptyLabelScope();
|
|
LabelElement lookup(String label) => null;
|
|
LabelScope get outer() {
|
|
throw 'internal error: empty label scope has no outer';
|
|
}
|
|
}
|
|
|
|
class StatementScope {
|
|
LabelScope labels;
|
|
Link<TargetElement> breakTargetStack;
|
|
Link<TargetElement> continueTargetStack;
|
|
// Used to provide different numbers to statements if one is inside the other.
|
|
// Can be used to make otherwise duplicate labels unique.
|
|
int nestingLevel = 0;
|
|
|
|
StatementScope()
|
|
: labels = const EmptyLabelScope(),
|
|
breakTargetStack = const EmptyLink<TargetElement>(),
|
|
continueTargetStack = const EmptyLink<TargetElement>();
|
|
|
|
LabelElement lookupLabel(String label) {
|
|
return labels.lookup(label);
|
|
}
|
|
|
|
TargetElement currentBreakTarget() =>
|
|
breakTargetStack.isEmpty() ? null : breakTargetStack.head;
|
|
|
|
TargetElement currentContinueTarget() =>
|
|
continueTargetStack.isEmpty() ? null : continueTargetStack.head;
|
|
|
|
void enterLabelScope(Map<String, LabelElement> elements) {
|
|
labels = new LabeledStatementLabelScope(labels, elements);
|
|
nestingLevel++;
|
|
}
|
|
|
|
void exitLabelScope() {
|
|
nestingLevel--;
|
|
labels = labels.outer;
|
|
}
|
|
|
|
void enterLoop(TargetElement element) {
|
|
breakTargetStack = breakTargetStack.prepend(element);
|
|
continueTargetStack = continueTargetStack.prepend(element);
|
|
nestingLevel++;
|
|
}
|
|
|
|
void exitLoop() {
|
|
nestingLevel--;
|
|
breakTargetStack = breakTargetStack.tail;
|
|
continueTargetStack = continueTargetStack.tail;
|
|
}
|
|
|
|
void enterSwitch(TargetElement breakElement,
|
|
Map<String, LabelElement> continueElements) {
|
|
breakTargetStack = breakTargetStack.prepend(breakElement);
|
|
labels = new SwitchLabelScope(labels, continueElements);
|
|
nestingLevel++;
|
|
}
|
|
|
|
void exitSwitch() {
|
|
nestingLevel--;
|
|
breakTargetStack = breakTargetStack.tail;
|
|
labels = labels.outer;
|
|
}
|
|
}
|
|
|
|
class TypeResolver {
|
|
final Compiler compiler;
|
|
|
|
TypeResolver(this.compiler);
|
|
|
|
Element resolveTypeName(Scope scope, TypeAnnotation node) {
|
|
Identifier typeName = node.typeName.asIdentifier();
|
|
Send send = node.typeName.asSend();
|
|
return resolveTypeNameInternal(scope, typeName, send);
|
|
}
|
|
|
|
Element resolveTypeNameInternal(Scope scope, Identifier typeName, Send send) {
|
|
if (send !== null) {
|
|
typeName = send.selector;
|
|
}
|
|
if (typeName.source.stringValue === 'void') {
|
|
return compiler.types.voidType.element;
|
|
} else if (send !== null) {
|
|
Element e = scope.lookup(send.receiver.asIdentifier().source);
|
|
if (e !== null && e.kind === ElementKind.PREFIX) {
|
|
// The receiver is a prefix. Lookup in the imported members.
|
|
PrefixElement prefix = e;
|
|
return prefix.lookupLocalMember(typeName.source);
|
|
} else if (e !== null && e.kind === ElementKind.CLASS) {
|
|
// The receiver is the class part of a named constructor.
|
|
return e;
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
return scope.lookup(typeName.source);
|
|
}
|
|
}
|
|
|
|
// TODO(johnniwinther): Change [onFailure] and [whenResolved] to use boolean
|
|
// flags instead of closures.
|
|
// TODO(johnniwinther): Should never return [null] but instead an erroneous
|
|
// type.
|
|
Type resolveTypeAnnotation(TypeAnnotation node,
|
|
[Scope inScope, ClassElement inClass,
|
|
onFailure(Node, MessageKind, [List arguments]),
|
|
whenResolved(Node, Type)]) {
|
|
if (onFailure === null) {
|
|
onFailure = (n, k, [arguments]) {};
|
|
}
|
|
if (whenResolved === null) {
|
|
whenResolved = (n, t) {};
|
|
}
|
|
if (inClass !== null) {
|
|
inScope = inClass.buildScope();
|
|
}
|
|
if (inScope === null) {
|
|
compiler.internalError('resolveTypeAnnotation: no scope specified');
|
|
}
|
|
return resolveTypeAnnotationInContext(inScope, node, onFailure,
|
|
whenResolved);
|
|
}
|
|
|
|
Type resolveTypeAnnotationInContext(Scope scope, TypeAnnotation node,
|
|
onFailure, whenResolved) {
|
|
Element element = resolveTypeName(scope, node);
|
|
Type type;
|
|
if (element === null) {
|
|
onFailure(node, MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
|
|
} else if (!element.impliesType()) {
|
|
onFailure(node, MessageKind.NOT_A_TYPE, [node.typeName]);
|
|
} else {
|
|
if (element === compiler.types.voidType.element ||
|
|
element === compiler.types.dynamicType.element) {
|
|
type = element.computeType(compiler);
|
|
} else if (element.isClass()) {
|
|
ClassElement cls = element;
|
|
cls.ensureResolved(compiler);
|
|
Link<Type> arguments =
|
|
resolveTypeArguments(node, cls.typeVariables, scope,
|
|
onFailure, whenResolved);
|
|
if (cls.typeVariables.isEmpty() && arguments.isEmpty()) {
|
|
// Use the canonical type if it has no type parameters.
|
|
type = cls.computeType(compiler);
|
|
} else {
|
|
type = new InterfaceType(cls, arguments);
|
|
}
|
|
} else if (element.isTypedef()) {
|
|
TypedefElement typdef = element;
|
|
// TODO(ahe): Should be [ensureResolved].
|
|
compiler.resolveTypedef(typdef);
|
|
typdef.computeType(compiler);
|
|
Link<Type> arguments = resolveTypeArguments(
|
|
node, typdef.typeVariables,
|
|
scope, onFailure, whenResolved);
|
|
if (typdef.typeVariables.isEmpty() && arguments.isEmpty()) {
|
|
// Return the canonical type if it has no type parameters.
|
|
type = typdef.computeType(compiler);
|
|
} else {
|
|
type = new TypedefType(typdef, arguments);
|
|
}
|
|
} else if (element.isTypeVariable()) {
|
|
type = element.computeType(compiler);
|
|
} else {
|
|
compiler.cancel("unexpected element kind ${element.kind}",
|
|
node: node);
|
|
}
|
|
}
|
|
whenResolved(node, type);
|
|
return type;
|
|
}
|
|
|
|
Link<Type> resolveTypeArguments(TypeAnnotation node,
|
|
Link<Type> typeVariables,
|
|
Scope scope, onFailure, whenResolved) {
|
|
if (node.typeArguments == null) {
|
|
return const EmptyLink<Type>();
|
|
}
|
|
var arguments = new LinkBuilder<Type>();
|
|
for (Link<Node> typeArguments = node.typeArguments.nodes;
|
|
!typeArguments.isEmpty();
|
|
typeArguments = typeArguments.tail) {
|
|
if (typeVariables.isEmpty()) {
|
|
onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
|
|
}
|
|
Type argType = resolveTypeAnnotationInContext(scope,
|
|
typeArguments.head,
|
|
onFailure,
|
|
whenResolved);
|
|
arguments.addLast(argType);
|
|
if (!typeVariables.isEmpty()) {
|
|
typeVariables = typeVariables.tail;
|
|
}
|
|
}
|
|
if (!typeVariables.isEmpty()) {
|
|
onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
|
|
}
|
|
return arguments.toLink();
|
|
}
|
|
}
|
|
|
|
class ResolverVisitor extends CommonResolverVisitor<Element> {
|
|
final TreeElementMapping mapping;
|
|
final Element enclosingElement;
|
|
final TypeResolver typeResolver;
|
|
bool inInstanceContext;
|
|
Scope scope;
|
|
ClassElement currentClass;
|
|
bool typeRequired = false;
|
|
StatementScope statementScope;
|
|
int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
|
|
|
|
ResolverVisitor(Compiler compiler, Element element)
|
|
: this.mapping = new TreeElementMapping(),
|
|
this.enclosingElement = element,
|
|
inInstanceContext = element.isInstanceMember()
|
|
|| element.isGenerativeConstructor(),
|
|
this.currentClass = element.isMember() ?
|
|
element.getEnclosingClass() :
|
|
null,
|
|
this.statementScope = new StatementScope(),
|
|
typeResolver = new TypeResolver(compiler),
|
|
scope = element.buildEnclosingScope(),
|
|
super(compiler) {
|
|
}
|
|
|
|
Enqueuer get world() => compiler.enqueuer.resolution;
|
|
|
|
Element lookup(Node node, SourceString name) {
|
|
Element result = scope.lookup(name);
|
|
if (!inInstanceContext && result != null && result.isInstanceMember()) {
|
|
error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Create, or reuse an already created, statement element for a statement.
|
|
TargetElement getOrCreateTargetElement(Node statement) {
|
|
TargetElement element = mapping[statement];
|
|
if (element === null) {
|
|
element = new TargetElement(statement,
|
|
statementScope.nestingLevel,
|
|
enclosingElement);
|
|
mapping[statement] = element;
|
|
}
|
|
return element;
|
|
}
|
|
|
|
inStaticContext(action()) {
|
|
bool wasInstanceContext = inInstanceContext;
|
|
inInstanceContext = false;
|
|
var result = action();
|
|
inInstanceContext = wasInstanceContext;
|
|
return result;
|
|
}
|
|
|
|
visitInStaticContext(Node node) {
|
|
inStaticContext(() => visit(node));
|
|
}
|
|
|
|
Element visitIdentifier(Identifier node) {
|
|
if (node.isThis()) {
|
|
if (!inInstanceContext) {
|
|
error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
|
|
}
|
|
return null;
|
|
} else if (node.isSuper()) {
|
|
if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
|
|
if ((ElementCategory.SUPER & allowedCategory) == 0) {
|
|
error(node, MessageKind.INVALID_USE_OF_SUPER);
|
|
}
|
|
return null;
|
|
} else {
|
|
Element element = lookup(node, node.source);
|
|
if (element === null) {
|
|
if (!inInstanceContext) error(node, MessageKind.CANNOT_RESOLVE, [node]);
|
|
} else {
|
|
if ((element.kind.category & allowedCategory) == 0) {
|
|
// TODO(ahe): Improve error message. Need UX input.
|
|
error(node, MessageKind.GENERIC, ["is not an expression $element"]);
|
|
}
|
|
}
|
|
return useElement(node, element);
|
|
}
|
|
}
|
|
|
|
Element visitTypeAnnotation(TypeAnnotation node) {
|
|
Type type = resolveTypeAnnotation(node);
|
|
if (type !== null) return type.element;
|
|
return null;
|
|
}
|
|
|
|
Element defineElement(Node node, Element element,
|
|
[bool doAddToScope = true]) {
|
|
compiler.ensure(element !== null);
|
|
mapping[node] = element;
|
|
if (doAddToScope) {
|
|
Element existing = scope.add(element);
|
|
if (existing != element) {
|
|
error(node, MessageKind.DUPLICATE_DEFINITION, [node]);
|
|
}
|
|
}
|
|
return element;
|
|
}
|
|
|
|
Element useElement(Node node, Element element) {
|
|
if (element === null) return null;
|
|
return mapping[node] = element;
|
|
}
|
|
|
|
Type useType(TypeAnnotation annotation, Type type) {
|
|
if (type !== null) {
|
|
mapping.setType(annotation, type);
|
|
useElement(annotation, type.element);
|
|
}
|
|
return type;
|
|
}
|
|
|
|
void setupFunction(FunctionExpression node, FunctionElement function) {
|
|
scope = new MethodScope(scope, function);
|
|
// Put the parameters in scope.
|
|
FunctionSignature functionParameters =
|
|
function.computeSignature(compiler);
|
|
Link<Node> parameterNodes = (node.parameters === null)
|
|
? const EmptyLink<Node>() : node.parameters.nodes;
|
|
functionParameters.forEachParameter((Element element) {
|
|
if (element == functionParameters.optionalParameters.head) {
|
|
NodeList nodes = parameterNodes.head;
|
|
parameterNodes = nodes.nodes;
|
|
}
|
|
VariableDefinitions variableDefinitions = parameterNodes.head;
|
|
Node parameterNode = variableDefinitions.definitions.nodes.head;
|
|
initializerDo(parameterNode, (n) => n.accept(this));
|
|
// Field parameters (this.x) are not visible inside the constructor. The
|
|
// fields they reference are visible, but must be resolved independently.
|
|
if (element.kind == ElementKind.FIELD_PARAMETER) {
|
|
useElement(parameterNode, element);
|
|
} else {
|
|
defineElement(variableDefinitions.definitions.nodes.head, element);
|
|
}
|
|
parameterNodes = parameterNodes.tail;
|
|
});
|
|
}
|
|
|
|
visitCascade(Cascade node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
visitCascadeReceiver(CascadeReceiver node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
Element visitClassNode(ClassNode node) {
|
|
cancel(node, "shouldn't be called");
|
|
}
|
|
|
|
visitIn(Node node, Scope nestedScope) {
|
|
scope = nestedScope;
|
|
Element element = visit(node);
|
|
scope = scope.parent;
|
|
return element;
|
|
}
|
|
|
|
/**
|
|
* Introduces new default targets for break and continue
|
|
* before visiting the body of the loop
|
|
*/
|
|
visitLoopBodyIn(Node loop, Node body, Scope bodyScope) {
|
|
TargetElement element = getOrCreateTargetElement(loop);
|
|
statementScope.enterLoop(element);
|
|
visitIn(body, bodyScope);
|
|
statementScope.exitLoop();
|
|
if (!element.isTarget) {
|
|
mapping.remove(loop);
|
|
}
|
|
}
|
|
|
|
visitBlock(Block node) {
|
|
visitIn(node.statements, new BlockScope(scope));
|
|
}
|
|
|
|
visitDoWhile(DoWhile node) {
|
|
visitLoopBodyIn(node, node.body, new BlockScope(scope));
|
|
visit(node.condition);
|
|
}
|
|
|
|
visitEmptyStatement(EmptyStatement node) { }
|
|
|
|
visitExpressionStatement(ExpressionStatement node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
visitFor(For node) {
|
|
Scope blockScope = new BlockScope(scope);
|
|
visitIn(node.initializer, blockScope);
|
|
visitIn(node.condition, blockScope);
|
|
visitIn(node.update, blockScope);
|
|
visitLoopBodyIn(node, node.body, blockScope);
|
|
}
|
|
|
|
visitFunctionDeclaration(FunctionDeclaration node) {
|
|
assert(node.function.name !== null);
|
|
visit(node.function);
|
|
FunctionElement functionElement = mapping[node.function];
|
|
// TODO(floitsch): this might lead to two errors complaining about
|
|
// shadowing.
|
|
defineElement(node, functionElement);
|
|
}
|
|
|
|
visitFunctionExpression(FunctionExpression node) {
|
|
visit(node.returnType);
|
|
SourceString name;
|
|
if (node.name === null) {
|
|
name = const SourceString("");
|
|
} else {
|
|
name = node.name.asIdentifier().source;
|
|
}
|
|
FunctionElement enclosing = new FunctionElement.node(
|
|
name, node, ElementKind.FUNCTION, new Modifiers.empty(),
|
|
scope.element);
|
|
setupFunction(node, enclosing);
|
|
defineElement(node, enclosing, doAddToScope: node.name !== null);
|
|
|
|
// Run the body in a fresh statement scope.
|
|
StatementScope oldScope = statementScope;
|
|
statementScope = new StatementScope();
|
|
visit(node.body);
|
|
statementScope = oldScope;
|
|
|
|
scope = scope.parent;
|
|
}
|
|
|
|
visitIf(If node) {
|
|
visit(node.condition);
|
|
visit(node.thenPart);
|
|
visit(node.elsePart);
|
|
}
|
|
|
|
static bool isLogicalOperator(Identifier op) {
|
|
String str = op.source.stringValue;
|
|
return (str === '&&' || str == '||' || str == '!');
|
|
}
|
|
|
|
Element resolveSend(Send node) {
|
|
Selector selector = resolveSelector(node);
|
|
|
|
if (node.receiver === null) {
|
|
return node.selector.accept(this);
|
|
}
|
|
|
|
var oldCategory = allowedCategory;
|
|
allowedCategory |=
|
|
ElementCategory.CLASS | ElementCategory.PREFIX | ElementCategory.SUPER;
|
|
Element resolvedReceiver = visit(node.receiver);
|
|
allowedCategory = oldCategory;
|
|
|
|
Element target;
|
|
SourceString name = node.selector.asIdentifier().source;
|
|
if (name.stringValue === 'this') {
|
|
error(node.selector, MessageKind.GENERIC, ["expected an identifier"]);
|
|
} else if (node.isSuperCall) {
|
|
if (node.isOperator) {
|
|
if (isUserDefinableOperator(name.stringValue)) {
|
|
name = selector.name;
|
|
} else {
|
|
error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, [name]);
|
|
}
|
|
}
|
|
if (!inInstanceContext) {
|
|
error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, [name]);
|
|
return null;
|
|
}
|
|
if (currentClass.supertype === null) {
|
|
// This is just to guard against internal errors, so no need
|
|
// for a real error message.
|
|
error(node.receiver, MessageKind.GENERIC, ["Object has no superclass"]);
|
|
}
|
|
target = currentClass.lookupSuperMember(name);
|
|
// [target] may be null which means invoking noSuchMethod on
|
|
// super.
|
|
} else if (resolvedReceiver === null) {
|
|
return null;
|
|
} else if (resolvedReceiver.kind === ElementKind.CLASS) {
|
|
ClassElement receiverClass = resolvedReceiver;
|
|
target = receiverClass.ensureResolved(compiler).lookupLocalMember(name);
|
|
if (target === null) {
|
|
error(node, MessageKind.METHOD_NOT_FOUND, [receiverClass.name, name]);
|
|
} else if (target.isInstanceMember()) {
|
|
error(node, MessageKind.MEMBER_NOT_STATIC, [receiverClass.name, name]);
|
|
}
|
|
} else if (resolvedReceiver.kind === ElementKind.PREFIX) {
|
|
PrefixElement prefix = resolvedReceiver;
|
|
target = prefix.lookupLocalMember(name);
|
|
if (target == null) {
|
|
error(node, MessageKind.NO_SUCH_LIBRARY_MEMBER, [prefix.name, name]);
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
Type resolveTypeTest(Node argument) {
|
|
TypeAnnotation node = argument.asTypeAnnotation();
|
|
if (node === null) {
|
|
// node is of the form !Type.
|
|
node = argument.asSend().receiver.asTypeAnnotation();
|
|
if (node === null) compiler.cancel("malformed send");
|
|
}
|
|
return resolveTypeRequired(node);
|
|
}
|
|
|
|
static Selector computeSendSelector(Send node, LibraryElement library) {
|
|
// First determine if this is part of an assignment.
|
|
bool isSet = node.asSendSet() !== null;
|
|
|
|
if (node.isIndex) {
|
|
return isSet ? new Selector.indexSet() : new Selector.index();
|
|
}
|
|
|
|
if (node.isOperator) {
|
|
SourceString source = node.selector.asOperator().source;
|
|
String string = source.stringValue;
|
|
if (string === '!' || string === '&&' || string == '||' ||
|
|
string === 'is' || string === 'as' ||
|
|
string === '===' || string === '!==' ||
|
|
string === '>>>') {
|
|
return null;
|
|
}
|
|
return node.arguments.isEmpty()
|
|
? new Selector.unaryOperator(source)
|
|
: new Selector.binaryOperator(source);
|
|
}
|
|
|
|
Identifier identifier = node.selector.asIdentifier();
|
|
if (node.isPropertyAccess) {
|
|
assert(!isSet);
|
|
return new Selector.getter(identifier.source, library);
|
|
} else if (isSet) {
|
|
return new Selector.setter(identifier.source, library);
|
|
}
|
|
|
|
// Compute the arity and the list of named arguments.
|
|
int arity = 0;
|
|
List<SourceString> named = <SourceString>[];
|
|
for (Link<Node> link = node.argumentsNode.nodes;
|
|
!link.isEmpty();
|
|
link = link.tail) {
|
|
Expression argument = link.head;
|
|
NamedArgument namedArgument = argument.asNamedArgument();
|
|
if (namedArgument !== null) {
|
|
named.add(namedArgument.name.source);
|
|
}
|
|
arity++;
|
|
}
|
|
|
|
// If we're invoking a closure, we do not have an identifier.
|
|
return (identifier === null)
|
|
? new Selector.callClosure(arity, named)
|
|
: new Selector.call(identifier.source, library, arity, named);
|
|
}
|
|
|
|
Selector resolveSelector(Send node) {
|
|
LibraryElement library = enclosingElement.getLibrary();
|
|
Selector selector = computeSendSelector(node, library);
|
|
if (selector != null) mapping.setSelector(node, selector);
|
|
return selector;
|
|
}
|
|
|
|
void resolveArguments(NodeList list) {
|
|
if (list === null) return;
|
|
bool seenNamedArgument = false;
|
|
for (Link<Node> link = list.nodes; !link.isEmpty(); link = link.tail) {
|
|
Expression argument = link.head;
|
|
visit(argument);
|
|
if (argument.asNamedArgument() != null) {
|
|
seenNamedArgument = true;
|
|
} else if (seenNamedArgument) {
|
|
error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
|
|
}
|
|
}
|
|
}
|
|
|
|
visitSend(Send node) {
|
|
Element target = resolveSend(node);
|
|
if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
|
|
AbstractFieldElement field = target;
|
|
target = field.getter;
|
|
}
|
|
|
|
bool resolvedArguments = false;
|
|
if (node.isOperator) {
|
|
String operatorString = node.selector.asOperator().source.stringValue;
|
|
if (operatorString === 'is' || operatorString === 'as') {
|
|
assert(node.arguments.tail.isEmpty());
|
|
resolveTypeTest(node.arguments.head);
|
|
resolvedArguments = true;
|
|
}
|
|
}
|
|
|
|
if (!resolvedArguments) {
|
|
resolveArguments(node.argumentsNode);
|
|
}
|
|
|
|
// If the selector is null, it means that we will not be generating
|
|
// code for this as a send.
|
|
Selector selector = mapping.getSelector(node);
|
|
if (selector === null) return;
|
|
|
|
// If we don't know what we're calling or if we are calling a getter,
|
|
// we need to register that fact that we may be calling a closure
|
|
// with the same arguments.
|
|
if (node.isCall &&
|
|
(target === null ||
|
|
target.isGetter() ||
|
|
Elements.isClosureSend(node, target))) {
|
|
Selector call = new Selector.callClosureFrom(selector);
|
|
world.registerDynamicInvocation(call.name, call);
|
|
}
|
|
|
|
// TODO(ngeoffray): We should do the check in
|
|
// visitExpressionStatement instead.
|
|
if (target === compiler.assertMethod && !node.isCall) {
|
|
// We can only use assert by calling it.
|
|
if (!inInstanceContext) {
|
|
error(node, MessageKind.MISSING_ARGUMENTS_TO_ASSERT, [node]);
|
|
}
|
|
target = null;
|
|
}
|
|
|
|
// TODO(ngeoffray): Warn if target is null and the send is
|
|
// unqualified.
|
|
useElement(node, target);
|
|
registerSend(selector, target);
|
|
return node.isPropertyAccess ? target : null;
|
|
}
|
|
|
|
visitSendSet(SendSet node) {
|
|
Element target = resolveSend(node);
|
|
Element setter = target;
|
|
Element getter = target;
|
|
if (target != null && target.kind == ElementKind.ABSTRACT_FIELD) {
|
|
AbstractFieldElement field = target;
|
|
setter = field.setter;
|
|
getter = field.getter;
|
|
}
|
|
|
|
visit(node.argumentsNode);
|
|
|
|
// TODO(ngeoffray): Check if the target can be assigned.
|
|
// TODO(ngeoffray): Warn if target is null and the send is
|
|
// unqualified.
|
|
|
|
Selector selector = mapping.getSelector(node);
|
|
String source = node.assignmentOperator.source.stringValue;
|
|
bool isComplex = source !== '=';
|
|
if (isComplex) {
|
|
if (selector.isSetter()) {
|
|
// TODO(kasperl): We're registering the getter selector for
|
|
// compound assignments on the AST selector node. In the code
|
|
// generator, we then fetch it from there when generating the
|
|
// getter for a SendSet node.
|
|
Selector getterSelector = new Selector.getterFrom(selector);
|
|
registerSend(getterSelector, getter);
|
|
mapping.setSelector(node.selector, getterSelector);
|
|
useElement(node.selector, getter);
|
|
} else {
|
|
// TODO(kasperl): If [getter] is resolved, it will actually
|
|
// refer to the []= operator which isn't the one we want to
|
|
// register here. We should consider using some notion of
|
|
// abstract indexable element that we can resolve to so we can
|
|
// distinguish the two.
|
|
assert(selector.isIndexSet());
|
|
registerSend(new Selector.index(), null);
|
|
}
|
|
|
|
// Make sure we include the + and - operators if we are using
|
|
// the ++ and -- ones.
|
|
void registerBinaryOperator(SourceString name) {
|
|
Selector binop = new Selector.binaryOperator(name);
|
|
world.registerDynamicInvocation(binop.name, binop);
|
|
}
|
|
if (source === '++') registerBinaryOperator(const SourceString('+'));
|
|
if (source === '--') registerBinaryOperator(const SourceString('-'));
|
|
}
|
|
|
|
registerSend(selector, setter);
|
|
return useElement(node, setter);
|
|
}
|
|
|
|
void registerSend(Selector selector, Element target) {
|
|
if (target === null || target.isInstanceMember()) {
|
|
if (selector.isGetter()) {
|
|
world.registerDynamicGetter(selector.name, selector);
|
|
} else if (selector.isSetter()) {
|
|
world.registerDynamicSetter(selector.name, selector);
|
|
} else {
|
|
world.registerDynamicInvocation(selector.name, selector);
|
|
}
|
|
} else if (Elements.isStaticOrTopLevel(target)) {
|
|
// TODO(kasperl): It seems like we're not supposed to register
|
|
// the use of classes. Wouldn't it be simpler if we just did?
|
|
if (!target.isClass()) world.registerStaticUse(target);
|
|
}
|
|
|
|
// TODO(kasperl): Pass the selector directly.
|
|
var interceptor = new Interceptors(compiler).getStaticInterceptor(
|
|
selector.name,
|
|
selector.argumentCount);
|
|
if (interceptor !== null) {
|
|
world.registerStaticUse(interceptor);
|
|
}
|
|
}
|
|
|
|
visitLiteralInt(LiteralInt node) {
|
|
}
|
|
|
|
visitLiteralDouble(LiteralDouble node) {
|
|
}
|
|
|
|
visitLiteralBool(LiteralBool node) {
|
|
}
|
|
|
|
visitLiteralString(LiteralString node) {
|
|
}
|
|
|
|
visitLiteralNull(LiteralNull node) {
|
|
}
|
|
|
|
visitStringJuxtaposition(StringJuxtaposition node) {
|
|
node.visitChildren(this);
|
|
}
|
|
|
|
visitNodeList(NodeList node) {
|
|
for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
|
|
visit(link.head);
|
|
}
|
|
}
|
|
|
|
visitOperator(Operator node) {
|
|
unimplemented(node, 'operator');
|
|
}
|
|
|
|
visitReturn(Return node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
visitThrow(Throw node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
visitVariableDefinitions(VariableDefinitions node) {
|
|
visit(node.type);
|
|
VariableDefinitionsVisitor visitor =
|
|
new VariableDefinitionsVisitor(compiler, node, this,
|
|
ElementKind.VARIABLE);
|
|
visitor.visit(node.definitions);
|
|
}
|
|
|
|
visitWhile(While node) {
|
|
visit(node.condition);
|
|
visitLoopBodyIn(node, node.body, new BlockScope(scope));
|
|
}
|
|
|
|
visitParenthesizedExpression(ParenthesizedExpression node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
visitNewExpression(NewExpression node) {
|
|
Node selector = node.send.selector;
|
|
FunctionElement constructor = resolveConstructor(node);
|
|
resolveSelector(node.send);
|
|
resolveArguments(node.send.argumentsNode);
|
|
useElement(node.send, constructor);
|
|
if (Element.isInvalid(constructor)) return constructor;
|
|
// TODO(karlklose): handle optional arguments.
|
|
if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
|
|
// TODO(ngeoffray): resolution error with wrong number of
|
|
// parameters. We cannot do this rigth now because of the
|
|
// List constructor.
|
|
}
|
|
world.registerStaticUse(constructor);
|
|
compiler.withCurrentElement(constructor, () {
|
|
FunctionExpression tree = constructor.parseNode(compiler);
|
|
compiler.resolver.resolveConstructorImplementation(constructor, tree);
|
|
});
|
|
world.registerStaticUse(constructor.defaultImplementation);
|
|
ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
|
|
world.registerInstantiatedClass(cls);
|
|
cls.forEachInstanceField(
|
|
includeBackendMembers: false,
|
|
includeSuperMembers: true,
|
|
f: (ClassElement enclosingClass, Element member) {
|
|
world.addToWorkList(member);
|
|
});
|
|
return null;
|
|
}
|
|
|
|
TypeAnnotation getTypeAnnotationFromSend(Send send) {
|
|
if (send.selector.asTypeAnnotation() !== null) {
|
|
return send.selector;
|
|
} else if (send.selector.asSend() !== null) {
|
|
Send selector = send.selector;
|
|
if (selector.receiver.asTypeAnnotation() !== null) {
|
|
return selector.receiver;
|
|
}
|
|
} else {
|
|
compiler.internalError("malformed send in new expression");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Try to resolve the constructor that is referred to by [node].
|
|
* Note: this function may return an ErroneousFunctionElement instead of
|
|
* [null], if there is no corresponding constructor, class or library.
|
|
*/
|
|
FunctionElement resolveConstructor(NewExpression node) {
|
|
FunctionElement constructor =
|
|
node.accept(new ConstructorResolver(compiler, this));
|
|
TypeAnnotation annotation = getTypeAnnotationFromSend(node.send);
|
|
// TODO(karlklose): clean up: the type should be resolved in the
|
|
// constructor resolver visitor to avoid visiting the node twice.
|
|
resolveTypeRequired(annotation);
|
|
return constructor;
|
|
}
|
|
|
|
Type resolveTypeRequired(TypeAnnotation node) {
|
|
bool old = typeRequired;
|
|
typeRequired = true;
|
|
Type result = resolveTypeAnnotation(node);
|
|
typeRequired = old;
|
|
return result;
|
|
}
|
|
|
|
Type resolveTypeAnnotation(TypeAnnotation node) {
|
|
Function report = typeRequired ? error : warning;
|
|
return typeResolver.resolveTypeAnnotation(node, inScope: scope,
|
|
onFailure: report,
|
|
whenResolved: useType);
|
|
}
|
|
|
|
visitModifiers(Modifiers node) {
|
|
// TODO(ngeoffray): Implement this.
|
|
unimplemented(node, 'modifiers');
|
|
}
|
|
|
|
visitLiteralList(LiteralList node) {
|
|
visit(node.elements);
|
|
}
|
|
|
|
visitConditional(Conditional node) {
|
|
node.visitChildren(this);
|
|
}
|
|
|
|
visitStringInterpolation(StringInterpolation node) {
|
|
node.visitChildren(this);
|
|
}
|
|
|
|
visitStringInterpolationPart(StringInterpolationPart node) {
|
|
SourceString name = const SourceString('toString');
|
|
LibraryElement library = enclosingElement.getLibrary();
|
|
Selector selector = new Selector.call(name, library, 0);
|
|
world.registerDynamicInvocation(name, selector);
|
|
node.visitChildren(this);
|
|
}
|
|
|
|
visitBreakStatement(BreakStatement node) {
|
|
TargetElement target;
|
|
if (node.target === null) {
|
|
target = statementScope.currentBreakTarget();
|
|
if (target === null) {
|
|
error(node, MessageKind.NO_BREAK_TARGET);
|
|
return;
|
|
}
|
|
target.isBreakTarget = true;
|
|
} else {
|
|
String labelName = node.target.source.slowToString();
|
|
LabelElement label = statementScope.lookupLabel(labelName);
|
|
if (label === null) {
|
|
error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
|
|
return;
|
|
}
|
|
target = label.target;
|
|
if (!target.statement.isValidBreakTarget()) {
|
|
error(node.target, MessageKind.INVALID_BREAK, [labelName]);
|
|
return;
|
|
}
|
|
label.setBreakTarget();
|
|
mapping[node.target] = label;
|
|
}
|
|
mapping[node] = target;
|
|
}
|
|
|
|
visitContinueStatement(ContinueStatement node) {
|
|
TargetElement target;
|
|
if (node.target === null) {
|
|
target = statementScope.currentContinueTarget();
|
|
if (target === null) {
|
|
error(node, MessageKind.NO_CONTINUE_TARGET);
|
|
return;
|
|
}
|
|
target.isContinueTarget = true;
|
|
} else {
|
|
String labelName = node.target.source.slowToString();
|
|
LabelElement label = statementScope.lookupLabel(labelName);
|
|
if (label === null) {
|
|
error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
|
|
return;
|
|
}
|
|
target = label.target;
|
|
if (!target.statement.isValidContinueTarget()) {
|
|
error(node.target, MessageKind.INVALID_CONTINUE, [labelName]);
|
|
}
|
|
// TODO(lrn): Handle continues to switch cases.
|
|
if (target.statement is SwitchCase) {
|
|
unimplemented(node, "continue to switch case");
|
|
}
|
|
label.setContinueTarget();
|
|
mapping[node.target] = label;
|
|
}
|
|
mapping[node] = target;
|
|
}
|
|
|
|
visitForIn(ForIn node) {
|
|
visit(node.expression);
|
|
Scope blockScope = new BlockScope(scope);
|
|
Node declaration = node.declaredIdentifier;
|
|
visitIn(declaration, blockScope);
|
|
visitLoopBodyIn(node, node.body, blockScope);
|
|
|
|
// TODO(lrn): Also allow a single identifier.
|
|
if ((declaration is !Send || declaration.asSend().selector is !Identifier)
|
|
&& (declaration is !VariableDefinitions ||
|
|
!declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty()))
|
|
{
|
|
// The variable declaration is either not an identifier, not a
|
|
// declaration, or it's declaring more than one variable.
|
|
error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN, []);
|
|
}
|
|
}
|
|
|
|
visitLabel(Label node) {
|
|
// Labels are handled by their containing statements/cases.
|
|
}
|
|
|
|
visitLabeledStatement(LabeledStatement node) {
|
|
Statement body = node.statement;
|
|
TargetElement targetElement = getOrCreateTargetElement(body);
|
|
Map<String, LabelElement> labelElements = <String, LabelElement>{};
|
|
for (Label label in node.labels) {
|
|
String labelName = label.slowToString();
|
|
if (labelElements.containsKey(labelName)) continue;
|
|
LabelElement element = targetElement.addLabel(label, labelName);
|
|
labelElements[labelName] = element;
|
|
}
|
|
statementScope.enterLabelScope(labelElements);
|
|
visit(node.statement);
|
|
statementScope.exitLabelScope();
|
|
labelElements.forEach((String labelName, LabelElement element) {
|
|
if (element.isTarget) {
|
|
mapping[element.label] = element;
|
|
} else {
|
|
warning(element.label, MessageKind.UNUSED_LABEL, [labelName]);
|
|
}
|
|
});
|
|
if (!targetElement.isTarget && mapping[body] === targetElement) {
|
|
// If the body is itself a break or continue for another target, it
|
|
// might have updated its mapping to the target it actually does target.
|
|
mapping.remove(body);
|
|
}
|
|
}
|
|
|
|
visitLiteralMap(LiteralMap node) {
|
|
node.visitChildren(this);
|
|
}
|
|
|
|
visitLiteralMapEntry(LiteralMapEntry node) {
|
|
node.visitChildren(this);
|
|
}
|
|
|
|
visitNamedArgument(NamedArgument node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
visitSwitchStatement(SwitchStatement node) {
|
|
node.expression.accept(this);
|
|
|
|
TargetElement breakElement = getOrCreateTargetElement(node);
|
|
Map<String, LabelElement> continueLabels = <String, LabelElement>{};
|
|
Link<Node> cases = node.cases.nodes;
|
|
while (!cases.isEmpty()) {
|
|
SwitchCase switchCase = cases.head;
|
|
for (Node labelOrCase in switchCase.labelsAndCases) {
|
|
if (labelOrCase is! Label) continue;
|
|
Label label = labelOrCase;
|
|
String labelName = label.slowToString();
|
|
|
|
LabelElement existingElement = continueLabels[labelName];
|
|
if (existingElement !== null) {
|
|
// It's an error if the same label occurs twice in the same switch.
|
|
warning(label, MessageKind.DUPLICATE_LABEL, [labelName]);
|
|
error(existingElement.label, MessageKind.EXISTING_LABEL, [labelName]);
|
|
} else {
|
|
// It's only a warning if it shadows another label.
|
|
existingElement = statementScope.lookupLabel(labelName);
|
|
if (existingElement !== null) {
|
|
warning(label, MessageKind.DUPLICATE_LABEL, [labelName]);
|
|
warning(existingElement.label,
|
|
MessageKind.EXISTING_LABEL, [labelName]);
|
|
}
|
|
}
|
|
|
|
TargetElement targetElement =
|
|
new TargetElement(switchCase,
|
|
statementScope.nestingLevel,
|
|
enclosingElement);
|
|
mapping[switchCase] = targetElement;
|
|
|
|
LabelElement labelElement =
|
|
new LabelElement(label, labelName,
|
|
targetElement, enclosingElement);
|
|
mapping[label] = labelElement;
|
|
continueLabels[labelName] = labelElement;
|
|
}
|
|
cases = cases.tail;
|
|
// Test that only the last case, if any, is a default case.
|
|
if (switchCase.defaultKeyword !== null && !cases.isEmpty()) {
|
|
error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
|
|
}
|
|
}
|
|
|
|
statementScope.enterSwitch(breakElement, continueLabels);
|
|
node.cases.accept(this);
|
|
statementScope.exitSwitch();
|
|
|
|
// Clean-up unused labels.
|
|
continueLabels.forEach((String key, LabelElement label) {
|
|
if (!label.isContinueTarget) {
|
|
TargetElement targetElement = label.target;
|
|
SwitchCase switchCase = targetElement.statement;
|
|
mapping.remove(switchCase);
|
|
mapping.remove(label.label);
|
|
}
|
|
});
|
|
}
|
|
|
|
visitSwitchCase(SwitchCase node) {
|
|
node.labelsAndCases.accept(this);
|
|
visitIn(node.statements, new BlockScope(scope));
|
|
}
|
|
|
|
visitCaseMatch(CaseMatch node) {
|
|
visit(node.expression);
|
|
}
|
|
|
|
visitTryStatement(TryStatement node) {
|
|
visit(node.tryBlock);
|
|
if (node.catchBlocks.isEmpty() && node.finallyBlock == null) {
|
|
// TODO(ngeoffray): The precise location is
|
|
// node.getEndtoken.next. Adjust when issue #1581 is fixed.
|
|
error(node, MessageKind.NO_CATCH_NOR_FINALLY);
|
|
}
|
|
visit(node.catchBlocks);
|
|
visit(node.finallyBlock);
|
|
}
|
|
|
|
visitCatchBlock(CatchBlock node) {
|
|
Scope blockScope = new BlockScope(scope);
|
|
if (node.formals.isEmpty()) {
|
|
error(node, MessageKind.EMPTY_CATCH_DECLARATION);
|
|
} else if (!node.formals.nodes.tail.isEmpty()
|
|
&& !node.formals.nodes.tail.tail.isEmpty()) {
|
|
for (Node extra in node.formals.nodes.tail.tail) {
|
|
error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
|
|
}
|
|
}
|
|
visitIn(node.type, blockScope);
|
|
visitIn(node.formals, blockScope);
|
|
visitIn(node.block, blockScope);
|
|
}
|
|
|
|
visitTypedef(Typedef node) {
|
|
unimplemented(node, 'typedef');
|
|
}
|
|
}
|
|
|
|
class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
|
|
Scope scope;
|
|
TypeDeclarationElement element;
|
|
TypeResolver typeResolver;
|
|
|
|
TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
|
|
: this.element = element,
|
|
scope = element.buildEnclosingScope(),
|
|
typeResolver = new TypeResolver(compiler),
|
|
super(compiler);
|
|
|
|
void resolveTypeVariableBounds(NodeList node) {
|
|
if (node === null) return;
|
|
|
|
var nameSet = new Set<SourceString>();
|
|
// Resolve the bounds of type variables.
|
|
Link<Type> typeLink = element.typeVariables;
|
|
Link<Node> nodeLink = node.nodes;
|
|
while (!nodeLink.isEmpty()) {
|
|
TypeVariableType typeVariable = typeLink.head;
|
|
SourceString typeName = typeVariable.name;
|
|
TypeVariable typeNode = nodeLink.head;
|
|
if (nameSet.contains(typeName)) {
|
|
error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
|
|
}
|
|
nameSet.add(typeName);
|
|
|
|
TypeVariableElement variableElement = typeVariable.element;
|
|
if (typeNode.bound !== null) {
|
|
Type boundType = typeResolver.resolveTypeAnnotation(
|
|
typeNode.bound, inScope: scope, onFailure: warning);
|
|
if (boundType !== null && boundType.element == variableElement) {
|
|
// TODO(johnniwinther): Check for more general cycles, like
|
|
// [: <A extends B, B extends C, C extends B> :].
|
|
warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
|
|
[variableElement.name]);
|
|
} else if (boundType !== null) {
|
|
variableElement.bound = boundType;
|
|
} else {
|
|
// TODO(johnniwinther): Should be an erroneous type.
|
|
variableElement.bound = compiler.objectClass.computeType(compiler);
|
|
}
|
|
} else {
|
|
variableElement.bound = compiler.objectClass.computeType(compiler);
|
|
}
|
|
nodeLink = nodeLink.tail;
|
|
typeLink = typeLink.tail;
|
|
}
|
|
assert(typeLink.isEmpty());
|
|
}
|
|
}
|
|
|
|
class TypedefResolverVisitor extends TypeDefinitionVisitor {
|
|
TypedefElement get element() => super.element;
|
|
|
|
TypedefResolverVisitor(Compiler compiler, TypedefElement typedefElement)
|
|
: super(compiler, typedefElement);
|
|
|
|
visitTypedef(Typedef node) {
|
|
TypedefType type = element.computeType(compiler);
|
|
scope = new TypeDeclarationScope(scope, element);
|
|
resolveTypeVariableBounds(node.typeParameters);
|
|
|
|
element.functionSignature = SignatureResolver.analyze(
|
|
compiler, node.formals, node.returnType, element);
|
|
|
|
element.alias = compiler.computeFunctionType(
|
|
element, element.functionSignature);
|
|
|
|
// TODO(johnniwinther): Check for cyclic references in the typedef alias.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The implementation of [ResolverTask.resolveClass].
|
|
*
|
|
* This visitor has to be extra careful as it is building the basic
|
|
* element information, and cannot safely look at other elements as
|
|
* this may lead to cycles.
|
|
*
|
|
* This visitor can assume that the supertypes have already been
|
|
* resolved, but it cannot call [ResolverTask.resolveClass] directly
|
|
* or indirectly (through [ClassElement.ensureResolved]) for any other
|
|
* types.
|
|
*/
|
|
class ClassResolverVisitor extends TypeDefinitionVisitor {
|
|
ClassElement get element() => super.element;
|
|
|
|
ClassResolverVisitor(Compiler compiler, ClassElement classElement)
|
|
: super(compiler, classElement);
|
|
|
|
Type visitClassNode(ClassNode node) {
|
|
compiler.ensure(element !== null);
|
|
compiler.ensure(element.resolutionState == ClassElement.STATE_STARTED);
|
|
|
|
InterfaceType type = element.computeType(compiler);
|
|
scope = new TypeDeclarationScope(scope, element);
|
|
// TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
|
|
// As a side-effect, this may get us back here trying to
|
|
// resolve this class again.
|
|
resolveTypeVariableBounds(node.typeParameters);
|
|
|
|
// Find super type.
|
|
Type supertype = visit(node.superclass);
|
|
if (supertype !== null && supertype.element.isExtendable()) {
|
|
element.supertype = supertype;
|
|
if (isBlackListed(supertype)) {
|
|
error(node.superclass, MessageKind.CANNOT_EXTEND, [supertype]);
|
|
}
|
|
} else if (supertype !== null) {
|
|
error(node.superclass, MessageKind.TYPE_NAME_EXPECTED);
|
|
}
|
|
final objectElement = compiler.objectClass;
|
|
if (element !== objectElement && element.supertype === null) {
|
|
if (objectElement === null) {
|
|
compiler.internalError("Internal error: cannot resolve Object",
|
|
node: node);
|
|
} else {
|
|
objectElement.ensureResolved(compiler);
|
|
}
|
|
// TODO(ahe): This should be objectElement.computeType(...).
|
|
element.supertype = new InterfaceType(objectElement);
|
|
}
|
|
assert(element.interfaces === null);
|
|
Link<Type> interfaces = const EmptyLink<Type>();
|
|
for (Link<Node> link = node.interfaces.nodes;
|
|
!link.isEmpty();
|
|
link = link.tail) {
|
|
Type interfaceType = visit(link.head);
|
|
if (interfaceType !== null && interfaceType.element.isExtendable()) {
|
|
interfaces = interfaces.prepend(interfaceType);
|
|
if (isBlackListed(interfaceType)) {
|
|
error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
|
|
}
|
|
} else {
|
|
error(link.head, MessageKind.TYPE_NAME_EXPECTED);
|
|
}
|
|
}
|
|
element.interfaces = interfaces;
|
|
calculateAllSupertypes(element);
|
|
|
|
if (node.defaultClause !== null) {
|
|
element.defaultClass = visit(node.defaultClause);
|
|
}
|
|
addDefaultConstructorIfNeeded(element);
|
|
return element.computeType(compiler);
|
|
}
|
|
|
|
Type visitTypeAnnotation(TypeAnnotation node) {
|
|
return visit(node.typeName);
|
|
}
|
|
|
|
Type visitIdentifier(Identifier node) {
|
|
Element element = scope.lookup(node.source);
|
|
if (element === null) {
|
|
error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
|
|
return null;
|
|
} else if (!element.impliesType() && !element.isTypeVariable()) {
|
|
error(node, MessageKind.NOT_A_TYPE, [node]);
|
|
return null;
|
|
} else {
|
|
if (element.isTypeVariable()) {
|
|
TypeVariableElement variableElement = element;
|
|
return variableElement.type;
|
|
} else if (element.isTypedef()) {
|
|
compiler.unimplemented('visitIdentifier for typedefs', node: node);
|
|
} else {
|
|
// TODO(ngeoffray): Use type variables.
|
|
return element.computeType(compiler);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
Type visitSend(Send node) {
|
|
Identifier prefix = node.receiver.asIdentifier();
|
|
if (prefix === null) {
|
|
error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
|
|
return null;
|
|
}
|
|
Element element = scope.lookup(prefix.source);
|
|
if (element === null || element.kind !== ElementKind.PREFIX) {
|
|
error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
|
|
return null;
|
|
}
|
|
PrefixElement prefixElement = element;
|
|
Identifier selector = node.selector.asIdentifier();
|
|
var e = prefixElement.lookupLocalMember(selector.source);
|
|
if (e === null || !e.impliesType()) {
|
|
error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
|
|
return null;
|
|
}
|
|
return e.computeType(compiler);
|
|
}
|
|
|
|
void calculateAllSupertypes(ClassElement cls) {
|
|
// TODO(karlklose): substitute type variables.
|
|
// TODO(karlklose): check if type arguments match, if a classelement occurs
|
|
// more than once in the supertypes.
|
|
if (cls.allSupertypes !== null) return;
|
|
final Type supertype = cls.supertype;
|
|
if (supertype != null) {
|
|
ClassElement superElement = supertype.element;
|
|
Link<Type> superSupertypes = superElement.allSupertypes;
|
|
assert(superSupertypes !== null);
|
|
Link<Type> supertypes = new Link<Type>(supertype, superSupertypes);
|
|
for (Link<Type> interfaces = cls.interfaces;
|
|
!interfaces.isEmpty();
|
|
interfaces = interfaces.tail) {
|
|
ClassElement element = interfaces.head.element;
|
|
Link<Type> interfaceSupertypes = element.allSupertypes;
|
|
assert(interfaceSupertypes !== null);
|
|
supertypes = supertypes.reversePrependAll(interfaceSupertypes);
|
|
supertypes = supertypes.prepend(interfaces.head);
|
|
}
|
|
cls.allSupertypes = supertypes;
|
|
} else {
|
|
assert(cls === compiler.objectClass);
|
|
cls.allSupertypes = const EmptyLink<Type>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a synthetic nullary constructor if there are no other
|
|
* constructors.
|
|
*/
|
|
void addDefaultConstructorIfNeeded(ClassElement element) {
|
|
if (element.hasConstructor) return;
|
|
SynthesizedConstructorElement constructor =
|
|
new SynthesizedConstructorElement(element);
|
|
element.addToScope(constructor, compiler);
|
|
Type returnType = compiler.types.voidType;
|
|
constructor.type = new FunctionType(returnType, const EmptyLink<Type>(),
|
|
constructor);
|
|
constructor.cachedNode =
|
|
new FunctionExpression(new Identifier(element.position()),
|
|
new NodeList.empty(),
|
|
new Block(new NodeList.empty()),
|
|
null, null, null, null);
|
|
}
|
|
|
|
isBlackListed(Type type) {
|
|
LibraryElement lib = element.getLibrary();
|
|
return
|
|
lib !== compiler.coreLibrary &&
|
|
lib !== compiler.coreImplLibrary &&
|
|
lib !== compiler.jsHelperLibrary &&
|
|
(type.element === compiler.dynamicClass ||
|
|
type.element === compiler.boolClass ||
|
|
type.element === compiler.numClass ||
|
|
type.element === compiler.intClass ||
|
|
type.element === compiler.doubleClass ||
|
|
type.element === compiler.stringClass ||
|
|
type.element === compiler.nullClass ||
|
|
type.element === compiler.functionClass);
|
|
}
|
|
}
|
|
|
|
class ClassSupertypeResolver extends CommonResolverVisitor {
|
|
Scope context;
|
|
ClassElement classElement;
|
|
|
|
ClassSupertypeResolver(Compiler compiler, ClassElement cls)
|
|
: context = new TopScope(cls.getLibrary()),
|
|
this.classElement = cls,
|
|
super(compiler);
|
|
|
|
void loadSupertype(ClassElement element, Node from) {
|
|
compiler.resolver.loadSupertypes(element, from);
|
|
element.ensureResolved(compiler);
|
|
}
|
|
|
|
void visitClassNode(ClassNode node) {
|
|
if (node.superclass === null) {
|
|
if (classElement !== compiler.objectClass) {
|
|
loadSupertype(compiler.objectClass, node);
|
|
}
|
|
} else {
|
|
node.superclass.accept(this);
|
|
}
|
|
for (Link<Node> link = node.interfaces.nodes;
|
|
!link.isEmpty();
|
|
link = link.tail) {
|
|
link.head.accept(this);
|
|
}
|
|
}
|
|
|
|
void visitTypeAnnotation(TypeAnnotation node) {
|
|
node.typeName.accept(this);
|
|
}
|
|
|
|
void visitIdentifier(Identifier node) {
|
|
Element element = context.lookup(node.source);
|
|
if (element === null) {
|
|
error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
|
|
} else if (!element.impliesType()) {
|
|
error(node, MessageKind.NOT_A_TYPE, [node]);
|
|
} else {
|
|
if (element.isClass()) {
|
|
loadSupertype(element, node);
|
|
} else {
|
|
compiler.reportMessage(
|
|
compiler.spanFromNode(node),
|
|
MessageKind.TYPE_NAME_EXPECTED.error([]),
|
|
api.Diagnostic.ERROR);
|
|
}
|
|
}
|
|
}
|
|
|
|
void visitSend(Send node) {
|
|
Identifier prefix = node.receiver.asIdentifier();
|
|
if (prefix === null) {
|
|
error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
|
|
return;
|
|
}
|
|
Element element = context.lookup(prefix.source);
|
|
if (element === null || element.kind !== ElementKind.PREFIX) {
|
|
error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
|
|
return;
|
|
}
|
|
PrefixElement prefixElement = element;
|
|
Identifier selector = node.selector.asIdentifier();
|
|
var e = prefixElement.lookupLocalMember(selector.source);
|
|
if (e === null || !e.impliesType()) {
|
|
error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
|
|
return;
|
|
}
|
|
loadSupertype(e, node);
|
|
}
|
|
}
|
|
|
|
class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
|
|
VariableDefinitions definitions;
|
|
ResolverVisitor resolver;
|
|
ElementKind kind;
|
|
VariableListElement variables;
|
|
|
|
VariableDefinitionsVisitor(Compiler compiler,
|
|
this.definitions, this.resolver, this.kind)
|
|
: super(compiler) {
|
|
variables = new VariableListElement.node(
|
|
definitions, ElementKind.VARIABLE_LIST, resolver.scope.element);
|
|
}
|
|
|
|
SourceString visitSendSet(SendSet node) {
|
|
assert(node.arguments.tail.isEmpty()); // Sanity check
|
|
resolver.visit(node.arguments.head);
|
|
return visit(node.selector);
|
|
}
|
|
|
|
SourceString visitIdentifier(Identifier node) => node.source;
|
|
|
|
visitNodeList(NodeList node) {
|
|
for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
|
|
SourceString name = visit(link.head);
|
|
VariableElement element = new VariableElement(
|
|
name, variables, kind, resolver.scope.element, node: link.head);
|
|
resolver.defineElement(link.head, element);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* [SignatureResolver] resolves function signatures.
|
|
*/
|
|
class SignatureResolver extends CommonResolverVisitor<Element> {
|
|
final Element enclosingElement;
|
|
Link<Element> optionalParameters = const EmptyLink<Element>();
|
|
int optionalParameterCount = 0;
|
|
VariableDefinitions currentDefinitions;
|
|
|
|
SignatureResolver(Compiler compiler, this.enclosingElement) : super(compiler);
|
|
|
|
Element visitNodeList(NodeList node) {
|
|
// This must be a list of optional arguments.
|
|
if (node.beginToken.stringValue !== '[') {
|
|
internalError(node, "expected optional parameters");
|
|
}
|
|
LinkBuilder<Element> elements = analyzeNodes(node.nodes);
|
|
optionalParameterCount = elements.length;
|
|
optionalParameters = elements.toLink();
|
|
return null;
|
|
}
|
|
|
|
Element visitVariableDefinitions(VariableDefinitions node) {
|
|
Link<Node> definitions = node.definitions.nodes;
|
|
if (definitions.isEmpty()) {
|
|
cancel(node, 'internal error: no parameter definition');
|
|
return null;
|
|
}
|
|
if (!definitions.tail.isEmpty()) {
|
|
cancel(definitions.tail.head, 'internal error: extra definition');
|
|
return null;
|
|
}
|
|
Node definition = definitions.head;
|
|
if (definition is NodeList) {
|
|
cancel(node, 'optional parameters are not implemented');
|
|
}
|
|
|
|
if (currentDefinitions != null) {
|
|
cancel(node, 'function type parameters not supported');
|
|
}
|
|
currentDefinitions = node;
|
|
Element element = definition.accept(this);
|
|
currentDefinitions = null;
|
|
return element;
|
|
}
|
|
|
|
Element visitIdentifier(Identifier node) {
|
|
Element variables = new VariableListElement.node(currentDefinitions,
|
|
ElementKind.VARIABLE_LIST, enclosingElement);
|
|
return new VariableElement(node.source, variables,
|
|
ElementKind.PARAMETER, enclosingElement, node: node);
|
|
}
|
|
|
|
SourceString getParameterName(Send node) {
|
|
var identifier = node.selector.asIdentifier();
|
|
if (identifier !== null) {
|
|
// Normal parameter: [:Type name:].
|
|
return identifier.source;
|
|
} else {
|
|
// Function type parameter: [:void name(Type arg):].
|
|
var functionExpression = node.selector.asFunctionExpression();
|
|
if (functionExpression !== null &&
|
|
functionExpression.name.asIdentifier() !== null) {
|
|
return functionExpression.name.asIdentifier().source;
|
|
} else {
|
|
cancel(node,
|
|
'internal error: unimplemented receiver on parameter send');
|
|
}
|
|
}
|
|
}
|
|
|
|
// The only valid [Send] can be in constructors and must be of the form
|
|
// [:this.x:] (where [:x:] represents an instance field).
|
|
FieldParameterElement visitSend(Send node) {
|
|
FieldParameterElement element;
|
|
if (node.receiver.asIdentifier() === null ||
|
|
!node.receiver.asIdentifier().isThis()) {
|
|
error(node, MessageKind.INVALID_PARAMETER, []);
|
|
} else if (enclosingElement.kind !== ElementKind.GENERATIVE_CONSTRUCTOR) {
|
|
error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED, []);
|
|
} else {
|
|
SourceString name = getParameterName(node);
|
|
Element fieldElement = currentClass.lookupLocalMember(name);
|
|
if (fieldElement === null || fieldElement.kind !== ElementKind.FIELD) {
|
|
error(node, MessageKind.NOT_A_FIELD, [name]);
|
|
} else if (!fieldElement.isInstanceMember()) {
|
|
error(node, MessageKind.NOT_INSTANCE_FIELD, [name]);
|
|
}
|
|
Element variables = new VariableListElement.node(currentDefinitions,
|
|
ElementKind.VARIABLE_LIST, enclosingElement);
|
|
element = new FieldParameterElement(name,
|
|
fieldElement, variables, enclosingElement, node);
|
|
}
|
|
return element;
|
|
}
|
|
|
|
Element visitSendSet(SendSet node) {
|
|
Element element;
|
|
if (node.receiver != null) {
|
|
element = visitSend(node);
|
|
} else if (node.selector.asIdentifier() != null) {
|
|
Element variables = new VariableListElement.node(currentDefinitions,
|
|
ElementKind.VARIABLE_LIST, enclosingElement);
|
|
element = new VariableElement(node.selector.asIdentifier().source,
|
|
variables, ElementKind.PARAMETER, enclosingElement, node: node);
|
|
}
|
|
// Visit the value. The compile time constant handler will
|
|
// make sure it's a compile time constant.
|
|
resolveExpression(node.arguments.head);
|
|
return element;
|
|
}
|
|
|
|
Element visitFunctionExpression(FunctionExpression node) {
|
|
// This is a function typed parameter.
|
|
// TODO(ahe): Resolve the function type.
|
|
return visit(node.name);
|
|
}
|
|
|
|
LinkBuilder<Element> analyzeNodes(Link<Node> link) {
|
|
LinkBuilder<Element> elements = new LinkBuilder<Element>();
|
|
for (; !link.isEmpty(); link = link.tail) {
|
|
Element element = link.head.accept(this);
|
|
if (element != null) {
|
|
elements.addLast(element);
|
|
} else {
|
|
// If parameter is null, the current node should be the last,
|
|
// and a list of optional named parameters.
|
|
if (!link.tail.isEmpty() || (link.head is !NodeList)) {
|
|
internalError(link.head, "expected optional parameters");
|
|
}
|
|
}
|
|
}
|
|
return elements;
|
|
}
|
|
|
|
/**
|
|
* Resolves formal parameters and return type to a [FunctionSignature].
|
|
*/
|
|
static FunctionSignature analyze(Compiler compiler,
|
|
NodeList formalParameters,
|
|
Node returnNode,
|
|
Element element) {
|
|
SignatureResolver visitor = new SignatureResolver(compiler, element);
|
|
Link<Element> parameters = const EmptyLink<Element>();
|
|
int requiredParameterCount = 0;
|
|
if (formalParameters === null) {
|
|
if (!element.isGetter()) {
|
|
compiler.reportMessage(compiler.spanFromElement(element),
|
|
MessageKind.MISSING_FORMALS.error([]),
|
|
api.Diagnostic.ERROR);
|
|
}
|
|
} else {
|
|
if (element.isGetter()) {
|
|
if (!element.getLibrary().isPlatformLibrary) {
|
|
// TODO(ahe): Remove the isPlatformLibrary check.
|
|
if (formalParameters.getEndToken().next.stringValue !== 'native') {
|
|
// TODO(ahe): Remove the check for native keyword.
|
|
compiler.reportMessage(compiler.spanFromNode(formalParameters),
|
|
MessageKind.EXTRA_FORMALS.error([]),
|
|
api.Diagnostic.WARNING);
|
|
}
|
|
}
|
|
}
|
|
LinkBuilder<Element> parametersBuilder =
|
|
visitor.analyzeNodes(formalParameters.nodes);
|
|
requiredParameterCount = parametersBuilder.length;
|
|
parameters = parametersBuilder.toLink();
|
|
}
|
|
Type returnType = compiler.resolveTypeAnnotation(element, returnNode);
|
|
return new FunctionSignature(parameters,
|
|
visitor.optionalParameters,
|
|
requiredParameterCount,
|
|
visitor.optionalParameterCount,
|
|
returnType);
|
|
}
|
|
|
|
// TODO(ahe): This is temporary.
|
|
void resolveExpression(Node node) {
|
|
if (node == null) return;
|
|
node.accept(new ResolverVisitor(compiler, enclosingElement));
|
|
}
|
|
|
|
// TODO(ahe): This is temporary.
|
|
ClassElement get currentClass() {
|
|
return enclosingElement.isMember()
|
|
? enclosingElement.getEnclosingClass() : null;
|
|
}
|
|
}
|
|
|
|
class ConstructorResolver extends CommonResolverVisitor<Element> {
|
|
final ResolverVisitor resolver;
|
|
|
|
ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
|
|
|
|
visitNode(Node node) {
|
|
throw 'not supported';
|
|
}
|
|
|
|
FunctionElement lookupConstructor(ClassElement cls,
|
|
Node diagnosticNode,
|
|
SourceString constructorName) {
|
|
cls.ensureResolved(compiler);
|
|
Element result = cls.lookupConstructor(cls.name, constructorName);
|
|
if (result === null) {
|
|
String fullConstructorName = cls.name.slowToString();
|
|
if (constructorName !== const SourceString('')) {
|
|
fullConstructorName = '$fullConstructorName'
|
|
'.${constructorName.slowToString()}';
|
|
}
|
|
ResolutionWarning warning =
|
|
new ResolutionWarning(MessageKind.CANNOT_FIND_CONSTRUCTOR,
|
|
[fullConstructorName]);
|
|
compiler.reportWarning(diagnosticNode, warning);
|
|
return new ErroneousFunctionElement(warning.message, cls);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
visitNewExpression(NewExpression node) {
|
|
Node selector = node.send.selector;
|
|
Element e = visit(selector);
|
|
if (!Element.isInvalid(e) && e.kind === ElementKind.CLASS) {
|
|
ClassElement cls = e;
|
|
cls.ensureResolved(compiler);
|
|
if (cls.isInterface() && (cls.defaultClass === null)) {
|
|
error(selector, MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
|
|
}
|
|
e = lookupConstructor(cls, selector, const SourceString(''));
|
|
}
|
|
return e;
|
|
}
|
|
|
|
visitTypeAnnotation(TypeAnnotation node) {
|
|
// TODO(ahe): Do not ignore type arguments.
|
|
return visit(node.typeName);
|
|
}
|
|
|
|
visitSend(Send node) {
|
|
Element e = visit(node.receiver);
|
|
if (e === null) return null; // TODO(ahe): Return erroneous element.
|
|
|
|
Identifier name = node.selector.asIdentifier();
|
|
if (name === null) internalError(node.selector, 'unexpected node');
|
|
|
|
if (e.kind === ElementKind.CLASS) {
|
|
ClassElement cls = e;
|
|
cls.ensureResolved(compiler);
|
|
if (cls.isInterface() && (cls.defaultClass === null)) {
|
|
error(node.receiver, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
|
|
[cls.name]);
|
|
}
|
|
return lookupConstructor(cls, name, name.source);
|
|
} else if (e.kind === ElementKind.PREFIX) {
|
|
PrefixElement prefix = e;
|
|
e = prefix.lookupLocalMember(name.source);
|
|
if (e === null) {
|
|
error(name, MessageKind.CANNOT_RESOLVE, [name]);
|
|
// TODO(ahe): Return erroneous element.
|
|
} else if (e.kind !== ElementKind.CLASS) {
|
|
error(node, MessageKind.NOT_A_TYPE, [name]);
|
|
}
|
|
} else {
|
|
internalError(node.receiver, 'unexpected element $e');
|
|
}
|
|
return e;
|
|
}
|
|
|
|
Element visitIdentifier(Identifier node) {
|
|
SourceString name = node.source;
|
|
Element e = resolver.lookup(node, name);
|
|
if (e === null) {
|
|
error(node, MessageKind.CANNOT_RESOLVE, [name]);
|
|
// TODO(ahe): Return erroneous element.
|
|
} else if (e.kind === ElementKind.TYPEDEF) {
|
|
error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
|
|
} else if (e.kind !== ElementKind.CLASS && e.kind !== ElementKind.PREFIX) {
|
|
error(node, MessageKind.NOT_A_TYPE, [name]);
|
|
}
|
|
return e;
|
|
}
|
|
}
|
|
|
|
class Scope {
|
|
final Element element;
|
|
final Scope parent;
|
|
|
|
Scope(this.parent, this.element);
|
|
abstract Element add(Element element);
|
|
abstract Element lookup(SourceString name);
|
|
}
|
|
|
|
/**
|
|
* [TypeDeclarationScope] defines the outer scope of a type declaration in
|
|
* which the declared type variables and the entities in the enclosing scope are
|
|
* available but where declared and inherited members are not available. This
|
|
* scope is only used for class/interface declarations during resolution of the
|
|
* class hierarchy. In all other cases [ClassScope] is used.
|
|
*/
|
|
class TypeDeclarationScope extends Scope {
|
|
TypeDeclarationElement get element() => super.element;
|
|
|
|
TypeDeclarationScope(parent, TypeDeclarationElement element)
|
|
: super(parent, element) {
|
|
assert(parent !== null);
|
|
}
|
|
|
|
Element add(Element newElement) {
|
|
throw "Cannot add element to TypeDeclarationScope";
|
|
}
|
|
|
|
/**
|
|
* Looks up [name] within the type variables declared in [element].
|
|
*/
|
|
Element lookupTypeVariable(SourceString name) {
|
|
return null;
|
|
}
|
|
|
|
Element lookup(SourceString name) {
|
|
Link<Type> typeVariableLink = element.typeVariables;
|
|
while (!typeVariableLink.isEmpty()) {
|
|
TypeVariableType typeVariable = typeVariableLink.head;
|
|
if (typeVariable.name == name) {
|
|
return typeVariable.element;
|
|
}
|
|
typeVariableLink = typeVariableLink.tail;
|
|
}
|
|
|
|
return parent.lookup(name);
|
|
}
|
|
|
|
String toString() =>
|
|
'$element${element.typeVariables} > $parent';
|
|
}
|
|
|
|
class MethodScope extends Scope {
|
|
final Map<SourceString, Element> elements;
|
|
|
|
MethodScope(Scope parent, Element element)
|
|
: super(parent, element),
|
|
this.elements = new Map<SourceString, Element>() {
|
|
assert(parent !== null);
|
|
}
|
|
|
|
Element lookup(SourceString name) {
|
|
Element found = elements[name];
|
|
if (found !== null) return found;
|
|
return parent.lookup(name);
|
|
}
|
|
|
|
Element add(Element newElement) {
|
|
if (elements.containsKey(newElement.name)) {
|
|
return elements[newElement.name];
|
|
}
|
|
elements[newElement.name] = newElement;
|
|
return newElement;
|
|
}
|
|
|
|
String toString() => '$element${elements.getKeys()} > $parent';
|
|
}
|
|
|
|
class BlockScope extends MethodScope {
|
|
BlockScope(Scope parent) : super(parent, parent.element);
|
|
|
|
String toString() => 'block${elements.getKeys()} > $parent';
|
|
}
|
|
|
|
/**
|
|
* [ClassScope] defines the inner scope of a class/interface declaration in
|
|
* which declared members, declared type variables, entities in the enclosing
|
|
* scope and inherited members are available, in the given order.
|
|
*/
|
|
class ClassScope extends TypeDeclarationScope {
|
|
ClassScope(Scope parentScope, ClassElement element)
|
|
: super(parentScope, element);
|
|
|
|
Element lookup(SourceString name) {
|
|
ClassElement cls = element;
|
|
Element result = cls.lookupLocalMember(name);
|
|
if (result !== null) return result;
|
|
result = super.lookup(name);
|
|
if (result != null) return result;
|
|
return cls.lookupSuperMember(name);
|
|
}
|
|
|
|
Element add(Element newElement) {
|
|
throw "Cannot add an element in a class scope";
|
|
}
|
|
|
|
String toString() => '$element > $parent';
|
|
}
|
|
|
|
class TopScope extends Scope {
|
|
LibraryElement get library() => element;
|
|
|
|
TopScope(LibraryElement library) : super(null, library);
|
|
Element lookup(SourceString name) {
|
|
return library.find(name);
|
|
}
|
|
|
|
Element add(Element newElement) {
|
|
throw "Cannot add an element in the top scope";
|
|
}
|
|
String toString() => '$element';
|
|
}
|