Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(507)

Unified Diff: pkg/compiler/lib/src/inferrer/type_system.dart

Issue 2979813002: Use entities in the TypeSystem interface. (Closed)
Patch Set: Created 3 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pkg/compiler/lib/src/inferrer/inferrer_engine.dart ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/compiler/lib/src/inferrer/type_system.dart
diff --git a/pkg/compiler/lib/src/inferrer/type_system.dart b/pkg/compiler/lib/src/inferrer/type_system.dart
index 5779c5805d9b871cdb0cbbc262836a7331c7f00e..43069e5ec998160dbbead9e01b02e21174c92afe 100644
--- a/pkg/compiler/lib/src/inferrer/type_system.dart
+++ b/pkg/compiler/lib/src/inferrer/type_system.dart
@@ -3,7 +3,20 @@
// BSD-style license that can be found in the LICENSE file.
import '../common.dart';
-import '../elements/elements.dart';
+import '../elements/elements.dart'
+ show
+ ClassElement,
+ ConstructorElement,
+ FieldElement,
+ FormalElement,
+ FunctionSignature,
+ FunctionTypedElement,
+ GetterElement,
+ LocalFunctionElement,
+ MemberElement,
+ MethodElement,
+ ParameterElement,
+ SetterElement;
import '../elements/entities.dart';
import '../elements/types.dart';
import '../tree/nodes.dart' as ast;
@@ -23,12 +36,12 @@ class TypeSystem {
final List<TypeInformation> _orderedTypeInformations = <TypeInformation>[];
/// [ParameterTypeInformation]s for parameters.
- final Map<ParameterElement, TypeInformation> parameterTypeInformations =
- new Map<ParameterElement, TypeInformation>();
+ final Map<Local, TypeInformation> parameterTypeInformations =
+ new Map<Local, TypeInformation>();
/// [MemberTypeInformation]s for members.
- final Map<MemberElement, TypeInformation> memberTypeInformations =
- new Map<MemberElement, TypeInformation>();
+ final Map<MemberEntity, TypeInformation> memberTypeInformations =
+ new Map<MemberEntity, TypeInformation>();
/// [ListTypeInformation] for allocated lists.
final Map<ast.Node, TypeInformation> allocatedLists =
@@ -80,7 +93,7 @@ class TypeSystem {
MemberTypeInformation _currentMember = null;
MemberTypeInformation get currentMember => _currentMember;
- void withMember(MemberElement element, action) {
+ void withMember(MemberEntity element, void action()) {
assert(_currentMember == null,
failedAt(element, "Already constructing graph for $_currentMember."));
_currentMember = getInferredTypeOfMember(element);
@@ -336,71 +349,75 @@ class TypeSystem {
return newType;
}
- ParameterTypeInformation getInferredTypeOfParameter(
+ ParameterTypeInformation _createParameterTypeInformation(
ParameterElement parameter) {
- assert(parameter.isImplementation);
-
- ParameterTypeInformation createTypeInformation() {
- FunctionTypedElement function = parameter.functionDeclaration.declaration;
- if (function.isLocal) {
- LocalFunctionElement localFunction = function;
- MethodElement callMethod = localFunction.callMethod;
- return new ParameterTypeInformation.localFunction(
- getInferredTypeOfMember(callMethod),
- parameter,
- parameter.type,
- callMethod);
- } else if (function.isInstanceMember) {
- MethodElement method = function;
- return new ParameterTypeInformation.instanceMember(
- getInferredTypeOfMember(method),
- parameter,
- parameter.type,
- method,
- new ParameterAssignments());
- } else {
- MethodElement method = function;
- return new ParameterTypeInformation.static(
- getInferredTypeOfMember(method), parameter, parameter.type, method,
- // TODO(johnniwinther): Is this still valid now that initializing
- // formals also introduce locals?
- isInitializingFormal: parameter.isInitializingFormal);
- }
+ FunctionTypedElement function = parameter.functionDeclaration.declaration;
+ if (function.isLocal) {
+ LocalFunctionElement localFunction = function;
+ MethodElement callMethod = localFunction.callMethod;
+ return new ParameterTypeInformation.localFunction(
+ getInferredTypeOfMember(callMethod),
+ parameter,
+ parameter.type,
+ callMethod);
+ } else if (function.isInstanceMember) {
+ MethodElement method = function;
+ return new ParameterTypeInformation.instanceMember(
+ getInferredTypeOfMember(method),
+ parameter,
+ parameter.type,
+ method,
+ new ParameterAssignments());
+ } else {
+ MethodElement method = function;
+ return new ParameterTypeInformation.static(
+ getInferredTypeOfMember(method), parameter, parameter.type, method,
+ // TODO(johnniwinther): Is this still valid now that initializing
+ // formals also introduce locals?
+ isInitializingFormal: parameter.isInitializingFormal);
}
+ }
+
+ ParameterTypeInformation getInferredTypeOfParameter(Local parameter) {
+ assert(!(parameter is ParameterElement && !parameter.isImplementation));
return parameterTypeInformations.putIfAbsent(parameter, () {
- ParameterTypeInformation typeInformation = createTypeInformation();
+ ParameterTypeInformation typeInformation =
+ _createParameterTypeInformation(parameter);
_orderedTypeInformations.add(typeInformation);
return typeInformation;
});
}
- MemberTypeInformation getInferredTypeOfMember(MemberElement member) {
- assert(member.isDeclaration);
- return memberTypeInformations.putIfAbsent(member, () {
- MemberTypeInformation typeInformation;
- if (member.isField) {
- FieldElement field = member;
- typeInformation = new FieldTypeInformation(field, field.type);
- } else if (member.isGetter) {
- GetterElement getter = member;
- typeInformation = new GetterTypeInformation(getter, getter.type);
- } else if (member.isSetter) {
- SetterElement setter = member;
- typeInformation = new SetterTypeInformation(setter);
- } else if (member.isFunction) {
- MethodElement method = member;
- typeInformation = new MethodTypeInformation(method, method.type);
+ MemberTypeInformation _createMemberTypeInformation(MemberElement member) {
+ if (member.isField) {
+ FieldElement field = member;
+ return new FieldTypeInformation(field, field.type);
+ } else if (member.isGetter) {
+ GetterElement getter = member;
+ return new GetterTypeInformation(getter, getter.type);
+ } else if (member.isSetter) {
+ SetterElement setter = member;
+ return new SetterTypeInformation(setter);
+ } else if (member.isFunction) {
+ MethodElement method = member;
+ return new MethodTypeInformation(method, method.type);
+ } else {
+ ConstructorElement constructor = member;
+ if (constructor.isFactoryConstructor) {
+ return new FactoryConstructorTypeInformation(
+ constructor, constructor.type);
} else {
- ConstructorElement constructor = member;
- if (constructor.isFactoryConstructor) {
- typeInformation = new FactoryConstructorTypeInformation(
- constructor, constructor.type);
- } else {
- typeInformation =
- new GenerativeConstructorTypeInformation(constructor);
- }
+ return new GenerativeConstructorTypeInformation(constructor);
}
+ }
+ }
+
+ MemberTypeInformation getInferredTypeOfMember(MemberEntity member) {
+ assert(!(member is MemberElement && !member.isDeclaration));
+ return memberTypeInformations.putIfAbsent(member, () {
+ MemberTypeInformation typeInformation =
+ _createMemberTypeInformation(member);
_orderedTypeInformations.add(typeInformation);
return typeInformation;
});
@@ -416,12 +433,19 @@ class TypeSystem {
});
}
- String getInferredSignatureOfMethod(MethodElement function) {
- ElementTypeInformation info = getInferredTypeOfMember(function);
+ void _forEachParameter(MethodElement function, void f(Local parameter)) {
MethodElement impl = function.implementation;
FunctionSignature signature = impl.functionSignature;
+ signature.forEachParameter((FormalElement _parameter) {
+ ParameterElement parameter = _parameter;
+ f(parameter);
+ });
+ }
+
+ String getInferredSignatureOfMethod(FunctionEntity function) {
+ ElementTypeInformation info = getInferredTypeOfMember(function);
var res = "";
- signature.forEachParameter((Element parameter) {
+ _forEachParameter(function, (Local parameter) {
TypeInformation type = getInferredTypeOfParameter(parameter);
res += "${res.isEmpty ? '(' : ', '}${type.type} ${parameter.name}";
});
@@ -429,19 +453,19 @@ class TypeSystem {
return res;
}
- TypeInformation nonNullSubtype(ClassElement type) {
- return getConcreteTypeFor(
- new TypeMask.nonNullSubtype(type.declaration, closedWorld));
+ TypeInformation nonNullSubtype(ClassEntity cls) {
+ assert(!(cls is ClassElement && !cls.isDeclaration));
+ return getConcreteTypeFor(new TypeMask.nonNullSubtype(cls, closedWorld));
}
- TypeInformation nonNullSubclass(ClassElement type) {
- return getConcreteTypeFor(
- new TypeMask.nonNullSubclass(type.declaration, closedWorld));
+ TypeInformation nonNullSubclass(ClassEntity cls) {
+ assert(!(cls is ClassElement && !cls.isDeclaration));
+ return getConcreteTypeFor(new TypeMask.nonNullSubclass(cls, closedWorld));
}
- TypeInformation nonNullExact(ClassElement type) {
- return getConcreteTypeFor(
- new TypeMask.nonNullExact(type.declaration, closedWorld));
+ TypeInformation nonNullExact(ClassEntity cls) {
+ assert(!(cls is ClassElement && !cls.isDeclaration));
+ return getConcreteTypeFor(new TypeMask.nonNullExact(cls, closedWorld));
}
TypeInformation nonNullEmpty() {
@@ -453,9 +477,9 @@ class TypeSystem {
}
TypeInformation allocateList(
- TypeInformation type, ast.Node node, MemberElement enclosing,
+ TypeInformation type, ast.Node node, MemberEntity enclosing,
[TypeInformation elementType, int length]) {
- ClassElement typedDataClass = closedWorld.commonElements.typedDataClass;
+ ClassEntity typedDataClass = closedWorld.commonElements.typedDataClass;
bool isTypedArray = typedDataClass != null &&
closedWorld.isInstantiated(typedDataClass) &&
type.type.satisfies(typedDataClass, closedWorld);
@@ -481,7 +505,7 @@ class TypeSystem {
/// Creates a [TypeInformation] object either for the closurization of a
/// static or top-level method [element] used as a function constant or for
/// the synthesized 'call' method [element] created for a local function.
- TypeInformation allocateClosure(ast.Node node, MethodElement element) {
+ TypeInformation allocateClosure(ast.Node node, FunctionEntity element) {
TypeInformation result =
new ClosureTypeInformation(currentMember, node, element);
allocatedClosures.add(result);
@@ -489,7 +513,7 @@ class TypeSystem {
}
TypeInformation allocateMap(
- ConcreteTypeInformation type, ast.Node node, MemberElement element,
+ ConcreteTypeInformation type, ast.Node node, MemberEntity element,
[List<TypeInformation> keyTypes, List<TypeInformation> valueTypes]) {
assert(keyTypes.length == valueTypes.length);
bool isFixed = (type.type == commonMasks.constMapType);
« no previous file with comments | « pkg/compiler/lib/src/inferrer/inferrer_engine.dart ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698