diff --git a/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 8809b85b14e..00e5fd1be29 100644 --- a/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -187,8 +187,8 @@ public class ExpressionCodegen extends JetVisitor { private void generateForInArray(JetForExpression expression, Type loopRangeType) { final JetParameter loopParameter = expression.getLoopParameter(); - final PropertyDescriptor parameterDescriptor = bindingContext.getParameterDescriptor(loopParameter); - JetType paramType = parameterDescriptor.getInType(); + final VariableDescriptor parameterDescriptor = bindingContext.getParameterDescriptor(loopParameter); + JetType paramType = parameterDescriptor.getOutType(); Type asmParamType = typeMapper.mapType(paramType); int lengthVar = myMap.enterTemp(); @@ -287,9 +287,9 @@ public class ExpressionCodegen extends JetVisitor { for (JetElement statement : statements) { if (statement instanceof JetProperty) { - final PropertyDescriptor propertyDescriptor = bindingContext.getPropertyDescriptor((JetProperty) statement); - final Type type = typeMapper.mapType(propertyDescriptor.getOutType()); - myMap.enter(propertyDescriptor, type.getSize()); + final VariableDescriptor variableDescriptor = bindingContext.getPropertyDescriptor((JetProperty) statement); + final Type type = typeMapper.mapType(variableDescriptor.getOutType()); + myMap.enter(variableDescriptor, type.getSize()); } } @@ -309,10 +309,10 @@ public class ExpressionCodegen extends JetVisitor { for (JetElement statement : statements) { if (statement instanceof JetProperty) { JetProperty var = (JetProperty) statement; - PropertyDescriptor propertyDescriptor = bindingContext.getPropertyDescriptor(var); - Type outType = typeMapper.mapType(propertyDescriptor.getOutType()); + VariableDescriptor variableDescriptor = bindingContext.getPropertyDescriptor(var); + Type outType = typeMapper.mapType(variableDescriptor.getOutType()); - int index = myMap.leave(propertyDescriptor); + int index = myMap.leave(variableDescriptor); v.visitLocalVariable(var.getName(), outType.getDescriptor(), null, blockStart, blockEnd, index); } } @@ -341,7 +341,7 @@ public class ExpressionCodegen extends JetVisitor { @Override public void visitSimpleNameExpression(JetSimpleNameExpression expression) { final DeclarationDescriptor descriptor = bindingContext.resolveReferenceExpression(expression); - if (descriptor instanceof PropertyDescriptor) { + if (descriptor instanceof VariableDescriptor) { final DeclarationDescriptor container = descriptor.getContainingDeclaration(); if (isClass(container, "Number")) { Type castType = getCastType(expression.getReferencedName()); @@ -367,7 +367,7 @@ public class ExpressionCodegen extends JetVisitor { else { int index = myMap.getIndex(descriptor); if (index >= 0) { - final JetType outType = ((PropertyDescriptor) descriptor).getOutType(); + final JetType outType = ((VariableDescriptor) descriptor).getOutType(); myStack.push(StackValue.local(index, typeMapper.mapType(outType))); } else { @@ -923,14 +923,14 @@ public class ExpressionCodegen extends JetVisitor { @Override public void visitProperty(JetProperty property) { - PropertyDescriptor propertyDescriptor = bindingContext.getPropertyDescriptor(property); - int index = myMap.getIndex(propertyDescriptor); + VariableDescriptor variableDescriptor = bindingContext.getPropertyDescriptor(property); + int index = myMap.getIndex(variableDescriptor); assert index >= 0; JetExpression initializer = property.getInitializer(); if (initializer != null) { - Type type = typeMapper.mapType(propertyDescriptor.getOutType()); + Type type = typeMapper.mapType(variableDescriptor.getOutType()); gen(initializer, type); v.store(index, type); } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java index 037626b5f9b..59d942ef956 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -12,8 +12,8 @@ public interface BindingContext { ClassDescriptor getClassDescriptor(JetClass declaration); TypeParameterDescriptor getTypeParameterDescriptor(JetTypeParameter declaration); FunctionDescriptor getFunctionDescriptor(JetFunction declaration); - PropertyDescriptor getPropertyDescriptor(JetProperty declaration); - PropertyDescriptor getParameterDescriptor(JetParameter declaration); + VariableDescriptor getPropertyDescriptor(JetProperty declaration); + VariableDescriptor getParameterDescriptor(JetParameter declaration); JetType getExpressionType(JetExpression expression); diff --git a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java b/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java index 482619560a2..c7ee7f96d0e 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java @@ -112,13 +112,13 @@ public class BindingTraceContext extends BindingTrace implements BindingContext } @Override - public PropertyDescriptor getPropertyDescriptor(JetProperty declaration) { - return (PropertyDescriptor) declarationsToDescriptors.get(declaration); + public VariableDescriptor getPropertyDescriptor(JetProperty declaration) { + return (VariableDescriptor) declarationsToDescriptors.get(declaration); } @Override - public PropertyDescriptor getParameterDescriptor(JetParameter declaration) { - return (PropertyDescriptor) declarationsToDescriptors.get(declaration); + public VariableDescriptor getParameterDescriptor(JetParameter declaration) { + return (VariableDescriptor) declarationsToDescriptors.get(declaration); } @Override diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java index 081a142c2c8..733a5bd2b66 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java @@ -129,7 +129,7 @@ public class ClassDescriptorResolver { @Override public void visitProperty(JetProperty property) { if (property.getPropertyTypeRef() != null) { - memberDeclarations.addPropertyDescriptor(resolvePropertyDescriptor(classDescriptor, typeParameterScope, property)); + memberDeclarations.addVariableDescriptor(resolvePropertyDescriptor(classDescriptor, typeParameterScope, property)); } else { // TODO : Caution: a cyclic dependency possible throw new UnsupportedOperationException(); @@ -217,7 +217,7 @@ public class ClassDescriptorResolver { result.add(valueParameterDescriptor); trace.recordDeclarationResolution(valueParameter, valueParameterDescriptor); - parameterScope.addPropertyDescriptor(valueParameterDescriptor); + parameterScope.addVariableDescriptor(valueParameterDescriptor); } return result; } @@ -268,9 +268,9 @@ public class ClassDescriptorResolver { } @NotNull - public PropertyDescriptor resolveValueParameterDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, @NotNull JetParameter parameter) { + public VariableDescriptor resolveLocalVariableDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, @NotNull JetParameter parameter) { JetType type = getParameterType(scope, parameter); - return resolveValueParameterDescriptor(containingDeclaration, parameter, type); + return resolveLocalVariableDescriptor(containingDeclaration, parameter, type); } private JetType getParameterType(JetScope scope, JetParameter parameter) { @@ -286,18 +286,45 @@ public class ClassDescriptorResolver { return type; } - public PropertyDescriptor resolveValueParameterDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetParameter parameter, @NotNull JetType type) { - PropertyDescriptor propertyDescriptor = new PropertyDescriptorImpl( + public VariableDescriptor resolveLocalVariableDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetParameter parameter, @NotNull JetType type) { + VariableDescriptor variableDescriptor = new LocalVariableDescriptor( containingDeclaration, AttributeResolver.INSTANCE.resolveAttributes(parameter.getModifierList()), JetPsiUtil.safeName(parameter.getName()), - parameter.isMutable() ? null : type, - type); - trace.recordDeclarationResolution(parameter, propertyDescriptor); + type, + parameter.isMutable()); + trace.recordDeclarationResolution(parameter, variableDescriptor); + return variableDescriptor; + } + + public VariableDescriptor resolveLocalVariableDescriptor(DeclarationDescriptor containingDeclaration, WritableScope scope, JetProperty property) { + JetType type = getType(scope, property); + + VariableDescriptorImpl propertyDescriptor = new LocalVariableDescriptor( + containingDeclaration, + AttributeResolver.INSTANCE.resolveAttributes(property.getModifierList()), + JetPsiUtil.safeName(property.getName()), + type, + property.isVar()); + trace.recordDeclarationResolution(property, propertyDescriptor); return propertyDescriptor; } - public PropertyDescriptor resolvePropertyDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, JetProperty property) { + public VariableDescriptor resolvePropertyDescriptor(@NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope scope, JetProperty property) { + JetType type = getType(scope, property); + + VariableDescriptorImpl propertyDescriptor = new PropertyDescriptor( + containingDeclaration, + AttributeResolver.INSTANCE.resolveAttributes(property.getModifierList()), + JetPsiUtil.safeName(property.getName()), + property.isVar() ? type : null, + type); + trace.recordDeclarationResolution(property, propertyDescriptor); + return propertyDescriptor; + } + + @NotNull + private JetType getType(@NotNull JetScope scope, @NotNull JetProperty property) { // TODO : receiver? JetTypeReference propertyTypeRef = property.getPropertyTypeRef(); @@ -314,15 +341,7 @@ public class ClassDescriptorResolver { } else { type = typeResolver.resolveType(scope, propertyTypeRef); } - - PropertyDescriptorImpl propertyDescriptor = new PropertyDescriptorImpl( - containingDeclaration, - AttributeResolver.INSTANCE.resolveAttributes(property.getModifierList()), - JetPsiUtil.safeName(property.getName()), - property.isVar() ? type : null, - type); - trace.recordDeclarationResolution(property, propertyDescriptor); - return propertyDescriptor; + return type; } @NotNull @@ -372,13 +391,13 @@ public class ClassDescriptorResolver { } } - public PropertyDescriptor resolvePrimaryConstructorParameterToAProperty( + public VariableDescriptor resolvePrimaryConstructorParameterToAProperty( @NotNull ClassDescriptor classDescriptor, @NotNull JetScope scope, @NotNull JetParameter parameter) { JetType type = getParameterType(scope, parameter); String name = parameter.getName(); - PropertyDescriptorImpl propertyDescriptor = new PropertyDescriptorImpl( + VariableDescriptorImpl propertyDescriptor = new PropertyDescriptor( classDescriptor, AttributeResolver.INSTANCE.resolveAttributes(parameter.getModifierList()), name == null ? "" : name, diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java b/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java index 18f361e9451..2c4edf2299c 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/JetScope.java @@ -25,7 +25,7 @@ public interface JetScope { NamespaceDescriptor getNamespace(@NotNull String name); @Nullable - PropertyDescriptor getProperty(@NotNull String name); + VariableDescriptor getVariable(@NotNull String name); @NotNull FunctionGroup getFunctionGroup(@NotNull String name); diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java index aba189f348c..7c8d465269f 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java @@ -39,8 +39,8 @@ public class JetScopeAdapter implements JetScope { } @Override - public PropertyDescriptor getProperty(@NotNull String name) { - return scope.getProperty(name); + public VariableDescriptor getVariable(@NotNull String name) { + return scope.getVariable(name); } @NotNull diff --git a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java index 85726ffe20e..83bb5e2b8ff 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java @@ -16,7 +16,7 @@ public abstract class JetScopeImpl implements JetScope { } @Override - public PropertyDescriptor getProperty(@NotNull String name) { + public VariableDescriptor getVariable(@NotNull String name) { return null; } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/LazySubstitutingClassDescriptor.java b/idea/src/org/jetbrains/jet/lang/resolve/LazySubstitutingClassDescriptor.java index 0aa16209bc1..b0f95a7d105 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/LazySubstitutingClassDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/LazySubstitutingClassDescriptor.java @@ -4,7 +4,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.types.*; import java.util.List; -import java.util.Map; /** * @author abreslav @@ -12,17 +11,17 @@ import java.util.Map; public class LazySubstitutingClassDescriptor implements ClassDescriptor { private final ClassDescriptor original; - private final Map substitutionContext; + private final TypeSubstitutor substitutor; - public LazySubstitutingClassDescriptor(ClassDescriptor descriptor, Map substitutionContext) { + public LazySubstitutingClassDescriptor(ClassDescriptor descriptor, TypeSubstitutor substitutor) { this.original = descriptor; - this.substitutionContext = substitutionContext; + this.substitutor = substitutor; } @NotNull @Override public TypeConstructor getTypeConstructor() { - if (substitutionContext.isEmpty()) { + if (substitutor.isEmpty()) { return original.getTypeConstructor(); } throw new UnsupportedOperationException(); // TODO @@ -32,10 +31,10 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor { @Override public JetScope getMemberScope(List typeArguments) { JetScope memberScope = original.getMemberScope(typeArguments); - if (substitutionContext.isEmpty()) { + if (substitutor.isEmpty()) { return memberScope; } - return new SubstitutingScope(memberScope, substitutionContext); + return new SubstitutingScope(memberScope, substitutor); // TODO : compose substitutors } @NotNull @@ -73,6 +72,12 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor { return original.getContainingDeclaration(); } + @NotNull + @Override + public ClassDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO + } + @Override public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitClassDescriptor(this, data); diff --git a/idea/src/org/jetbrains/jet/lang/resolve/MutableClassDescriptor.java b/idea/src/org/jetbrains/jet/lang/resolve/MutableClassDescriptor.java index 62d11e2f251..9440f7be2e1 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/MutableClassDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/MutableClassDescriptor.java @@ -37,8 +37,8 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme @Override public JetScope getMemberScope(List typeArguments) { List typeParameters = getTypeConstructor().getParameters(); - Map substitutionContext = TypeUtils.buildSubstitutionContext(typeParameters, typeArguments); - return new SubstitutingScope(unsubstitutedMemberScope, substitutionContext); + Map substitutionContext = TypeUtils.buildSubstitutionContext(typeParameters, typeArguments); + return new SubstitutingScope(unsubstitutedMemberScope, TypeSubstitutor.create(substitutionContext)); } @NotNull @@ -62,7 +62,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme return constructors; } Map substitutionContext = TypeUtils.buildSubstitutionContext(getTypeConstructor().getParameters(), typeArguments); - return new LazySubstitutingFunctionGroup(substitutionContext, constructors); + return new LazySubstitutingFunctionGroup(TypeSubstitutor.create(substitutionContext), constructors); } @NotNull @@ -75,6 +75,12 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme return classHeaderScope; } + @NotNull + @Override + public ClassDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO + } + @Override public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitClassDescriptor(this, data); diff --git a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java b/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java index cb5b5af1b8d..ce777ed3dda 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/ScopeWithReceiver.java @@ -28,8 +28,8 @@ public class ScopeWithReceiver extends JetScopeImpl { } @Override - public PropertyDescriptor getProperty(@NotNull String name) { - return receiverTypeScope.getProperty(name); + public VariableDescriptor getVariable(@NotNull String name) { + return receiverTypeScope.getVariable(name); // TODO : extension properties } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java b/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java index 0a6a36a1730..76686de0a2d 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java @@ -1,11 +1,9 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.types.*; import java.util.Collection; -import java.util.Map; /** * @author abreslav @@ -13,39 +11,22 @@ import java.util.Map; public class SubstitutingScope implements JetScope { private final JetScope workerScope; - private final Map substitutionContext; +// private final Map substitutionContext; + private final TypeSubstitutor substitutor; - public SubstitutingScope(JetScope workerScope, Map substitutionContext) { + public SubstitutingScope(JetScope workerScope, @NotNull TypeSubstitutor substitutor) { this.workerScope = workerScope; - this.substitutionContext = substitutionContext; + this.substitutor = substitutor; } @Override - public PropertyDescriptor getProperty(@NotNull String name) { - PropertyDescriptor property = workerScope.getProperty(name); - if (property == null || substitutionContext.isEmpty()) { - return property; + public VariableDescriptor getVariable(@NotNull String name) { + VariableDescriptor variable = workerScope.getVariable(name); + if (variable == null || substitutor.isEmpty()) { + return variable; } - JetType inType = substitute(property.getInType(), Variance.IN_VARIANCE); - JetType outType = substitute(property.getOutType(), Variance.OUT_VARIANCE); - if (inType == null && outType == null) { - return null; // TODO : tell the user that the property was projected out - } - return new PropertyDescriptorImpl( - property.getContainingDeclaration(), - property.getAttributes(), // TODO - property.getName(), - inType, - outType - ); - } - - @Nullable - private JetType substitute(@Nullable JetType originalType, @NotNull Variance variance) { - if (originalType == null) return null; - - return TypeSubstitutor.INSTANCE.substitute(substitutionContext, originalType, variance); + return variable.substitute(substitutor); } @Override @@ -55,7 +36,7 @@ public class SubstitutingScope implements JetScope { return null; } if (descriptor instanceof ClassDescriptor) { - return new LazySubstitutingClassDescriptor((ClassDescriptor) descriptor, substitutionContext); + return new LazySubstitutingClassDescriptor((ClassDescriptor) descriptor, substitutor); } throw new UnsupportedOperationException(); } @@ -75,10 +56,10 @@ public class SubstitutingScope implements JetScope { @Override public FunctionGroup getFunctionGroup(@NotNull String name) { FunctionGroup functionGroup = workerScope.getFunctionGroup(name); - if (substitutionContext.isEmpty()) { + if (substitutor.isEmpty()) { return functionGroup; } - return new LazySubstitutingFunctionGroup(substitutionContext, functionGroup); + return new LazySubstitutingFunctionGroup(substitutor, functionGroup); } @NotNull diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index e58a2cbd663..cd43e3949c7 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -211,12 +211,12 @@ public class TopDownAnalyzer { WritableScope memberScope = classDescriptor.getUnsubstitutedMemberScope(); // TODO : this is REALLY questionable ConstructorDescriptor constructorDescriptor = classDescriptorResolver.resolvePrimaryConstructor(memberScope, classDescriptor, klass); for (JetParameter parameter : klass.getPrimaryConstructorParameters()) { - PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePrimaryConstructorParameterToAProperty( + VariableDescriptor propertyDescriptor = classDescriptorResolver.resolvePrimaryConstructorParameterToAProperty( classDescriptor, memberScope, parameter ); - memberScope.addPropertyDescriptor( + memberScope.addVariableDescriptor( propertyDescriptor); } if (constructorDescriptor != null) { @@ -240,8 +240,8 @@ public class TopDownAnalyzer { private void processProperty(WritableScope declaringScope, JetProperty property) { declaringScopes.put(property, declaringScope); - PropertyDescriptor descriptor = classDescriptorResolver.resolvePropertyDescriptor(declaringScope.getContainingDeclaration(), declaringScope, property); - declaringScope.addPropertyDescriptor(descriptor); + VariableDescriptor descriptor = classDescriptorResolver.resolvePropertyDescriptor(declaringScope.getContainingDeclaration(), declaringScope, property); + declaringScope.addVariableDescriptor(descriptor); } private void processClassObject(JetClassObject classObject) { diff --git a/idea/src/org/jetbrains/jet/lang/resolve/WritableScope.java b/idea/src/org/jetbrains/jet/lang/resolve/WritableScope.java index 956bf4a8c8e..48daf603d5e 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/WritableScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/WritableScope.java @@ -18,7 +18,7 @@ public class WritableScope extends JetScopeAdapter { private final DeclarationDescriptor ownerDeclarationDescriptor; @Nullable - private Map propertyDescriptors; + private Map variableDescriptors; @Nullable private Map functionGroups; @Nullable @@ -93,37 +93,37 @@ public class WritableScope extends JetScopeAdapter { } @NotNull - private Map getPropertyDescriptors() { - if (propertyDescriptors == null) { - propertyDescriptors = new HashMap(); + private Map getVariableDescriptors() { + if (variableDescriptors == null) { + variableDescriptors = new HashMap(); } - return propertyDescriptors; + return variableDescriptors; } - public void addPropertyDescriptor(PropertyDescriptor propertyDescriptor) { - Map propertyDescriptors = getPropertyDescriptors(); - PropertyDescriptor existingDescriptor = propertyDescriptors.get(propertyDescriptor.getName()); + public void addVariableDescriptor(VariableDescriptor variableDescriptor) { + Map propertyDescriptors = getVariableDescriptors(); + VariableDescriptor existingDescriptor = propertyDescriptors.get(variableDescriptor.getName()); if (existingDescriptor != null) { - errorHandler.redeclaration(existingDescriptor, propertyDescriptor); + errorHandler.redeclaration(existingDescriptor, variableDescriptor); } // TODO : Should this always happen? - propertyDescriptors.put(propertyDescriptor.getName(), propertyDescriptor); + propertyDescriptors.put(variableDescriptor.getName(), variableDescriptor); } @Override - public PropertyDescriptor getProperty(@NotNull String name) { + public VariableDescriptor getVariable(@NotNull String name) { @NotNull - Map propertyDescriptors = getPropertyDescriptors(); - PropertyDescriptor propertyDescriptor = propertyDescriptors.get(name); - if (propertyDescriptor != null) { - return propertyDescriptor; + Map propertyDescriptors = getVariableDescriptors(); + VariableDescriptor variableDescriptor = propertyDescriptors.get(name); + if (variableDescriptor != null) { + return variableDescriptor; } - propertyDescriptor = super.getProperty(name); - if (propertyDescriptor != null) { - return propertyDescriptor; + variableDescriptor = super.getVariable(name); + if (variableDescriptor != null) { + return variableDescriptor; } for (JetScope imported : getImports()) { - PropertyDescriptor importedDescriptor = imported.getProperty(name); + VariableDescriptor importedDescriptor = imported.getVariable(name); if (importedDescriptor != null) { return importedDescriptor; } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java index de65abe6674..c310ee228ae 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java @@ -49,7 +49,7 @@ public class JavaClassMembersScope implements JetScope { } @Override - public PropertyDescriptor getProperty(@NotNull String name) { + public VariableDescriptor getVariable(@NotNull String name) { PsiField field = psiClass.findFieldByName(name, true); if (field == null) return null; if (field.hasModifierProperty(PsiModifier.STATIC) != staticMembers) { @@ -57,7 +57,7 @@ public class JavaClassMembersScope implements JetScope { } JetType type = semanticServices.getTypeTransformer().transform(field.getType()); - PropertyDescriptorImpl propertyDescriptor = new PropertyDescriptorImpl( + VariableDescriptorImpl propertyDescriptor = new PropertyDescriptor( containingDeclaration, Collections.emptyList(), field.getName(), diff --git a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 87556345e83..17b484ae4a9 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -16,6 +16,12 @@ import java.util.*; public class JavaDescriptorResolver { /*package*/ static final DeclarationDescriptor JAVA_ROOT = new DeclarationDescriptorImpl(null, Collections.emptyList(), "") { + @NotNull + @Override + public DeclarationDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO + } + @Override public R accept(DeclarationDescriptorVisitor visitor, D data) { throw new UnsupportedOperationException(); // TODO diff --git a/idea/src/org/jetbrains/jet/lang/types/ClassDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/ClassDescriptor.java index 5039f888a2b..f5f5917091f 100644 --- a/idea/src/org/jetbrains/jet/lang/types/ClassDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/ClassDescriptor.java @@ -25,4 +25,8 @@ public interface ClassDescriptor extends ClassifierDescriptor { */ @NotNull JetType getDefaultType(); + + @NotNull + @Override + ClassDescriptor substitute(TypeSubstitutor substitutor); } diff --git a/idea/src/org/jetbrains/jet/lang/types/ClassDescriptorImpl.java b/idea/src/org/jetbrains/jet/lang/types/ClassDescriptorImpl.java index 16172372d01..511d37a158c 100644 --- a/idea/src/org/jetbrains/jet/lang/types/ClassDescriptorImpl.java +++ b/idea/src/org/jetbrains/jet/lang/types/ClassDescriptorImpl.java @@ -49,7 +49,7 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl return memberDeclarations; } Map substitutionContext = TypeUtils.buildSubstitutionContext(typeConstructor.getParameters(), typeArguments); - return new SubstitutingScope(memberDeclarations, substitutionContext); + return new SubstitutingScope(memberDeclarations, TypeSubstitutor.create(substitutionContext)); } @NotNull @@ -66,7 +66,13 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl return constructors; } Map substitutionContext = TypeUtils.buildSubstitutionContext(getTypeConstructor().getParameters(), typeArguments); - return new LazySubstitutingFunctionGroup(substitutionContext, constructors); + return new LazySubstitutingFunctionGroup(TypeSubstitutor.create(substitutionContext), constructors); + } + + @NotNull + @Override + public ClassDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO } @Override diff --git a/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptor.java index 2f5fed12a87..fc7e1459001 100644 --- a/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptor.java @@ -16,10 +16,11 @@ public interface DeclarationDescriptor extends Annotated, Named { @NotNull DeclarationDescriptor getOriginal(); - @Nullable DeclarationDescriptor getContainingDeclaration(); + DeclarationDescriptor substitute(TypeSubstitutor substitutor); + R accept(DeclarationDescriptorVisitor visitor, D data); void acceptVoid(DeclarationDescriptorVisitor visitor); } diff --git a/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptorVisitor.java b/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptorVisitor.java index e2d608a3762..7041d78eb72 100644 --- a/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptorVisitor.java +++ b/idea/src/org/jetbrains/jet/lang/types/DeclarationDescriptorVisitor.java @@ -4,7 +4,7 @@ package org.jetbrains.jet.lang.types; * @author abreslav */ public class DeclarationDescriptorVisitor { - public R visitPropertyDescriptor(PropertyDescriptor descriptor, D data) { + public R visitVariableDescriptor(VariableDescriptor descriptor, D data) { return null; } @@ -24,11 +24,23 @@ public class DeclarationDescriptorVisitor { return null; } - public R visitModuleDeclaration(ModuleDescriptor moduleDescriptor, D data) { + public R visitModuleDeclaration(ModuleDescriptor descriptor, D data) { return null; } public R visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, D data) { return visitFunctionDescriptor(constructorDescriptor, data); } + + public R visitLocalVariableDescriptor(LocalVariableDescriptor descriptor, D data) { + return visitVariableDescriptor(descriptor, data); + } + + public R visitPropertyDescriptor(PropertyDescriptor descriptor, D data) { + return visitVariableDescriptor(descriptor, data); + } + + public R visitValueParameterDescriptor(ValueParameterDescriptor descriptor, D data) { + return visitVariableDescriptor(descriptor, data); + } } diff --git a/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java index 350ac27a007..8661e7d7f0b 100644 --- a/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/idea/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -20,7 +20,7 @@ public class ErrorUtils { } @Override - public PropertyDescriptor getProperty(@NotNull String name) { + public VariableDescriptor getVariable(@NotNull String name) { return ERROR_PROPERTY; } @@ -83,7 +83,7 @@ public class ErrorUtils { } private static final JetType ERROR_PROPERTY_TYPE = createErrorType(""); - private static final PropertyDescriptor ERROR_PROPERTY = new PropertyDescriptorImpl( + private static final VariableDescriptor ERROR_PROPERTY = new PropertyDescriptor( ERROR_CLASS, Collections.emptyList(), "", ERROR_PROPERTY_TYPE, ERROR_PROPERTY_TYPE); private static FunctionDescriptor createErrorFunction(List typeParameters, List positionedValueArgumentTypes) { diff --git a/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptor.java index ef004808936..cfa54413384 100644 --- a/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptor.java @@ -23,4 +23,7 @@ public interface FunctionDescriptor extends DeclarationDescriptor { @Override @NotNull DeclarationDescriptor getContainingDeclaration(); + + @Override + FunctionDescriptor substitute(TypeSubstitutor substitutor); } diff --git a/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorImpl.java b/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorImpl.java index 723f9e09ab6..c55aa470811 100644 --- a/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorImpl.java +++ b/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorImpl.java @@ -71,6 +71,11 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements return original; } + @Override + public FunctionDescriptor substitute(TypeSubstitutor substitutor) { + return FunctionDescriptorUtil.substituteFunctionDescriptor(this, substitutor); + } + @Override public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitFunctionDescriptor(this, data); diff --git a/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorUtil.java b/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorUtil.java index 1866fdeb2f5..c93e3b0382d 100644 --- a/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorUtil.java +++ b/idea/src/org/jetbrains/jet/lang/types/FunctionDescriptorUtil.java @@ -58,13 +58,13 @@ public class FunctionDescriptorUtil { } @Nullable - private static List getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, Map substitutionContext) { + private static List getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) { List result = new ArrayList(); List unsubstitutedValueParameters = functionDescriptor.getUnsubstitutedValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); // TODO : Lazy? - JetType substitutedType = TypeSubstitutor.INSTANCE.substitute(substitutionContext, unsubstitutedValueParameter.getOutType(), Variance.IN_VARIANCE); + JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getOutType(), Variance.IN_VARIANCE); if (substitutedType == null) return null; result.add(new ValueParameterDescriptorImpl( substitutedDescriptor, @@ -81,19 +81,19 @@ public class FunctionDescriptorUtil { } @Nullable - private static JetType getSubstitutedReturnType(@NotNull FunctionDescriptor functionDescriptor, Map substitutionContext) { - return TypeSubstitutor.INSTANCE.substitute(substitutionContext, functionDescriptor.getUnsubstitutedReturnType(), Variance.OUT_VARIANCE); + private static JetType getSubstitutedReturnType(@NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) { + return substitutor.substitute(functionDescriptor.getUnsubstitutedReturnType(), Variance.OUT_VARIANCE); } @Nullable public static FunctionDescriptor substituteFunctionDescriptor(@NotNull List typeArguments, @NotNull FunctionDescriptor functionDescriptor) { Map substitutionContext = createSubstitutionContext(functionDescriptor, typeArguments); - return substituteFunctionDescriptor(functionDescriptor, substitutionContext); + return substituteFunctionDescriptor(functionDescriptor, TypeSubstitutor.create(substitutionContext)); } @Nullable - public static FunctionDescriptor substituteFunctionDescriptor(FunctionDescriptor functionDescriptor, Map substitutionContext) { - if (substitutionContext.isEmpty()) { + public static FunctionDescriptor substituteFunctionDescriptor(FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) { + if (substitutor.isEmpty()) { return functionDescriptor; } FunctionDescriptorImpl substitutedDescriptor = new FunctionDescriptorImpl( @@ -102,12 +102,12 @@ public class FunctionDescriptorUtil { functionDescriptor.getAttributes(), functionDescriptor.getName()); - List substitutedValueParameters = getSubstitutedValueParameters(substitutedDescriptor, functionDescriptor, substitutionContext); + List substitutedValueParameters = getSubstitutedValueParameters(substitutedDescriptor, functionDescriptor, substitutor); if (substitutedValueParameters == null) { return null; } - JetType substitutedReturnType = getSubstitutedReturnType(functionDescriptor, substitutionContext); + JetType substitutedReturnType = getSubstitutedReturnType(functionDescriptor, substitutor); if (substitutedReturnType == null) { return null; } @@ -127,7 +127,7 @@ public class FunctionDescriptorUtil { parameterScope.addTypeParameterDescriptor(typeParameter); } for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getUnsubstitutedValueParameters()) { - parameterScope.addPropertyDescriptor(valueParameterDescriptor); + parameterScope.addVariableDescriptor(valueParameterDescriptor); } parameterScope.addLabeledDeclaration(descriptor); return parameterScope; diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java index 9c2d75f1d61..4c944b8afe6 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java @@ -275,13 +275,14 @@ public class JetTypeChecker { return; } handler.beforeChildren(current); - Map substitutionContext = TypeUtils.buildSubstitutionContext(current); +// Map substitutionContext = TypeUtils.buildSubstitutionContext(current); + TypeSubstitutor substitutor = TypeSubstitutor.create(current); for (JetType supertype : current.getConstructor().getSupertypes()) { TypeConstructor supertypeConstructor = supertype.getConstructor(); if (visited.contains(supertypeConstructor)) { continue; } - JetType substitutedSupertype = TypeSubstitutor.INSTANCE.safeSubstitute(substitutionContext, supertype, Variance.INVARIANT); + JetType substitutedSupertype = substitutor.safeSubstitute(supertype, Variance.INVARIANT); dfs(substitutedSupertype, visited, handler); } handler.afterChildren(current); @@ -336,7 +337,7 @@ public class JetTypeChecker { for (JetType immediateSupertype : constructor.getSupertypes()) { JetType correspondingSupertype = findCorrespondingSupertype(immediateSupertype, supertype); if (correspondingSupertype != null) { - return TypeSubstitutor.INSTANCE.safeSubstitute(subtype, correspondingSupertype, Variance.INVARIANT); + return TypeSubstitutor.create(subtype).safeSubstitute(correspondingSupertype, Variance.INVARIANT); } } return null; diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index c87768badf1..970b57b4db3 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -442,12 +442,12 @@ public class JetTypeInferrer { // TODO : type substitutions??? String referencedName = expression.getReferencedName(); if (referencedName != null) { - PropertyDescriptor property = scope.getProperty(referencedName); - if (property != null) { - trace.recordReferenceResolution(expression, property); - result = property.getOutType(); + VariableDescriptor variable = scope.getVariable(referencedName); + if (variable != null) { + trace.recordReferenceResolution(expression, variable); + result = variable.getOutType(); if (result == null) { - semanticServices.getErrorHandler().genericError(expression.getNode(), "This property is not readable in this context"); + semanticServices.getErrorHandler().genericError(expression.getNode(), "This variable is not readable in this context"); } return; } else { @@ -483,24 +483,24 @@ public class JetTypeInferrer { } List body = expression.getBody(); - final Map parameterDescriptors = new HashMap(); + final Map parameterDescriptors = new HashMap(); List parameterTypes = new ArrayList(); for (JetParameter parameter : expression.getParameters()) { JetTypeReference typeReference = parameter.getTypeReference(); if (typeReference == null) { throw new UnsupportedOperationException("Type inference for parameters is not implemented yet"); } - PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolveValueParameterDescriptor(functionDescriptor, scope, parameter); - parameterDescriptors.put(parameter.getName(), propertyDescriptor); - parameterTypes.add(propertyDescriptor.getOutType()); + VariableDescriptor variableDescriptor = classDescriptorResolver.resolveLocalVariableDescriptor(functionDescriptor, scope, parameter); + parameterDescriptors.put(parameter.getName(), variableDescriptor); + parameterTypes.add(variableDescriptor.getOutType()); } JetType returnType; if (returnTypeRef != null) { returnType = typeResolver.resolveType(scope, returnTypeRef); } else { WritableScope writableScope = semanticServices.createWritableScope(scope, functionDescriptor); - for (PropertyDescriptor propertyDescriptor : parameterDescriptors.values()) { - writableScope.addPropertyDescriptor(propertyDescriptor); + for (VariableDescriptor variableDescriptor : parameterDescriptors.values()) { + writableScope.addVariableDescriptor(variableDescriptor); } writableScope.setThisType(receiverType); returnType = getBlockReturnedType(writableScope, body); @@ -702,10 +702,10 @@ public class JetTypeInferrer { ClassDescriptor superclass = (ClassDescriptor) classifierCandidate; Collection supertypes = thisType.getConstructor().getSupertypes(); - Map substitutionContext = TypeUtils.buildSubstitutionContext(thisType); + TypeSubstitutor substitutor = TypeSubstitutor.create(thisType); for (JetType declaredSupertype : supertypes) { if (declaredSupertype.getConstructor().equals(superclass.getTypeConstructor())) { - result = TypeSubstitutor.INSTANCE.safeSubstitute(substitutionContext, declaredSupertype, Variance.INVARIANT); + result = substitutor.safeSubstitute(declaredSupertype, Variance.INVARIANT); break; } } @@ -849,10 +849,10 @@ public class JetTypeInferrer { if (loopParameter != null) { JetTypeReference typeReference = loopParameter.getTypeReference(); - PropertyDescriptor propertyDescriptor; + VariableDescriptor variableDescriptor; if (typeReference != null) { - propertyDescriptor = classDescriptorResolver.resolveValueParameterDescriptor(scope.getContainingDeclaration(), scope, loopParameter); - JetType actualParameterType = propertyDescriptor.getOutType(); + variableDescriptor = classDescriptorResolver.resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, loopParameter); + JetType actualParameterType = variableDescriptor.getOutType(); if (expectedParameterType != null && actualParameterType != null && !semanticServices.getTypeChecker().isSubtypeOf(expectedParameterType, actualParameterType)) { @@ -863,9 +863,9 @@ public class JetTypeInferrer { if (expectedParameterType == null) { expectedParameterType = ErrorUtils.createErrorType("Error"); } - propertyDescriptor = classDescriptorResolver.resolveValueParameterDescriptor(scope.getContainingDeclaration(), loopParameter, expectedParameterType); + variableDescriptor = classDescriptorResolver.resolveLocalVariableDescriptor(scope.getContainingDeclaration(), loopParameter, expectedParameterType); } - loopScope.addPropertyDescriptor(propertyDescriptor); + loopScope.addVariableDescriptor(variableDescriptor); } JetExpression body = expression.getBody(); @@ -926,7 +926,7 @@ public class JetTypeInferrer { } private boolean checkHasNextPropertySupport(@NotNull ASTNode reportErrorsOn, @NotNull JetType iteratorType) { - PropertyDescriptor hasNextProperty = iteratorType.getMemberScope().getProperty("hasNext"); + VariableDescriptor hasNextProperty = iteratorType.getMemberScope().getVariable("hasNext"); // TODO :extension properties if (hasNextProperty == null) { return false; @@ -1453,7 +1453,7 @@ public class JetTypeInferrer { semanticServices.getErrorHandler().genericError(setter.getNode(), "Local variables are not allowed to have setters"); } - PropertyDescriptor propertyDescriptor = classDescriptorResolver.resolvePropertyDescriptor(scope.getContainingDeclaration(), scope, property); + VariableDescriptor propertyDescriptor = classDescriptorResolver.resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, property); JetExpression initializer = property.getInitializer(); if (property.getPropertyTypeRef() != null && initializer != null) { JetType initializerType = getType(scope, initializer, false); @@ -1465,7 +1465,7 @@ public class JetTypeInferrer { } } - scope.addPropertyDescriptor(propertyDescriptor); + scope.addVariableDescriptor(propertyDescriptor); } @Override diff --git a/idea/src/org/jetbrains/jet/lang/types/LazySubstitutingFunctionGroup.java b/idea/src/org/jetbrains/jet/lang/types/LazySubstitutingFunctionGroup.java index c9923992945..faef947f4e9 100644 --- a/idea/src/org/jetbrains/jet/lang/types/LazySubstitutingFunctionGroup.java +++ b/idea/src/org/jetbrains/jet/lang/types/LazySubstitutingFunctionGroup.java @@ -7,17 +7,16 @@ import org.jetbrains.jet.lang.resolve.OverloadResolutionResult; import java.util.ArrayList; import java.util.Collection; import java.util.List; -import java.util.Map; /** * @author abreslav */ public class LazySubstitutingFunctionGroup implements FunctionGroup { - private final Map substitutionContext; + private final TypeSubstitutor substitutor; private final FunctionGroup functionGroup; - public LazySubstitutingFunctionGroup(Map substitutionContext, FunctionGroup functionGroup) { - this.substitutionContext = substitutionContext; + public LazySubstitutingFunctionGroup(TypeSubstitutor substitutor, FunctionGroup functionGroup) { + this.substitutor = substitutor; this.functionGroup = functionGroup; } @@ -35,7 +34,7 @@ public class LazySubstitutingFunctionGroup implements FunctionGroup { Collection result = new ArrayList(); for (FunctionDescriptor function : resolutionResult.getFunctionDescriptors()) { - FunctionDescriptor functionDescriptor = substitute(substitutionContext, function); + FunctionDescriptor functionDescriptor = substitute(function); if (functionDescriptor != null) { result.add(functionDescriptor); } @@ -44,16 +43,11 @@ public class LazySubstitutingFunctionGroup implements FunctionGroup { } @Nullable - public FunctionDescriptor substitute( - @NotNull Map substitutionContext, + private FunctionDescriptor substitute( @NotNull FunctionDescriptor functionDescriptor) { - if (substitutionContext.isEmpty()) return functionDescriptor; + if (substitutor.isEmpty()) return functionDescriptor; - FunctionDescriptor substituted = FunctionDescriptorUtil.substituteFunctionDescriptor(functionDescriptor, substitutionContext); - if (substituted == null) { - return null; - } - return substituted; + return functionDescriptor.substitute(substitutor); } @Override diff --git a/idea/src/org/jetbrains/jet/lang/types/LocalVariableDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/LocalVariableDescriptor.java new file mode 100644 index 00000000000..b38d65f89aa --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/types/LocalVariableDescriptor.java @@ -0,0 +1,31 @@ +package org.jetbrains.jet.lang.types; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.List; + +/** + * @author abreslav + */ +public class LocalVariableDescriptor extends VariableDescriptorImpl { + public LocalVariableDescriptor( + @NotNull DeclarationDescriptor containingDeclaration, + @NotNull List attributes, + @NotNull String name, + @Nullable JetType type, + boolean mutable) { + super(containingDeclaration, attributes, name, mutable ? type : null, type); + } + + @NotNull + @Override + public LocalVariableDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitLocalVariableDescriptor(this, data); + } +} diff --git a/idea/src/org/jetbrains/jet/lang/types/MemberDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/MemberDescriptor.java index 5ac7c0c259a..003a404274b 100644 --- a/idea/src/org/jetbrains/jet/lang/types/MemberDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/MemberDescriptor.java @@ -4,4 +4,7 @@ package org.jetbrains.jet.lang.types; * @author abreslav */ public interface MemberDescriptor { + boolean isAbstract(); + boolean isVirtual(); + boolean isOverride(); } diff --git a/idea/src/org/jetbrains/jet/lang/types/ModuleDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/ModuleDescriptor.java index 6318cb1f0c7..7579a7f97a0 100644 --- a/idea/src/org/jetbrains/jet/lang/types/ModuleDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/ModuleDescriptor.java @@ -1,5 +1,7 @@ package org.jetbrains.jet.lang.types; +import org.jetbrains.annotations.NotNull; + import java.util.Collections; /** @@ -10,6 +12,12 @@ public class ModuleDescriptor extends DeclarationDescriptorImpl { super(null, Collections.emptyList(), name); } + @NotNull + @Override + public ModuleDescriptor substitute(TypeSubstitutor substitutor) { + return this; + } + @Override public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitModuleDeclaration(this, data); diff --git a/idea/src/org/jetbrains/jet/lang/types/NamespaceDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/NamespaceDescriptor.java index f6d33a6292b..ac86cb5d552 100644 --- a/idea/src/org/jetbrains/jet/lang/types/NamespaceDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/NamespaceDescriptor.java @@ -35,6 +35,12 @@ public class NamespaceDescriptor extends DeclarationDescriptorImpl { return namespaceType; } + @NotNull + @Override + public NamespaceDescriptor substitute(TypeSubstitutor substitutor) { + return this; + } + @Override public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitNamespaceDescriptor(this, data); diff --git a/idea/src/org/jetbrains/jet/lang/types/PropertyAccessorDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/PropertyAccessorDescriptor.java new file mode 100644 index 00000000000..ca07110f5d5 --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/types/PropertyAccessorDescriptor.java @@ -0,0 +1,81 @@ +package org.jetbrains.jet.lang.types; + +import org.jetbrains.annotations.NotNull; + +import java.util.Collections; +import java.util.List; + +/** + * @author abreslav + */ +public class PropertyAccessorDescriptor extends DeclarationDescriptorImpl implements FunctionDescriptor { + public enum AccessorType { + GETTER("get"), + SETTER("set"); + + private final String name; + + AccessorType(String name) { + this.name = name; + } + + public String getName() { + return name; + } + } + + public static PropertyAccessorDescriptor createGetterDescriptor( + @NotNull PropertyDescriptor correspondingProperty, + @NotNull List attributes, + @NotNull JetType returnType + ) { + return new PropertyAccessorDescriptor(correspondingProperty, attributes, AccessorType.GETTER); + } + + public static PropertyAccessorDescriptor createSetterDescriptor( + @NotNull PropertyDescriptor correspondingProperty, + @NotNull List attributes, + @NotNull ValueParameterDescriptor parameter + ) { + return new PropertyAccessorDescriptor(correspondingProperty, attributes, AccessorType.SETTER); + } + + protected PropertyAccessorDescriptor(@NotNull PropertyDescriptor correspondingProperty, @NotNull List attributes, @NotNull AccessorType accessorType) { + super(correspondingProperty.getContainingDeclaration(), attributes, accessorType.getName()); + } + + @NotNull + @Override + public PropertyAccessorDescriptor getOriginal() { + return (PropertyAccessorDescriptor) super.getOriginal(); + } + + @NotNull + @Override + public FunctionDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO + } + + @NotNull + @Override + public List getTypeParameters() { + return Collections.emptyList(); + } + + @NotNull + @Override + public List getUnsubstitutedValueParameters() { + throw new UnsupportedOperationException(); // TODO + } + + @NotNull + @Override + public JetType getUnsubstitutedReturnType() { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + throw new UnsupportedOperationException(); // TODO + } +} diff --git a/idea/src/org/jetbrains/jet/lang/types/PropertyDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/PropertyDescriptor.java index b2168a6729c..c373c8faa98 100644 --- a/idea/src/org/jetbrains/jet/lang/types/PropertyDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/PropertyDescriptor.java @@ -3,24 +3,58 @@ package org.jetbrains.jet.lang.types; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.List; + /** * @author abreslav */ -public interface PropertyDescriptor extends DeclarationDescriptor { - /** - * @return null for write-only variables (i.e. properties), variable value type otherwise - */ - @Nullable - JetType getOutType(); +public class PropertyDescriptor extends VariableDescriptorImpl { - /** - * @return null for read-only variables (i.e. val's etc), or the type expected on assignment type otherwise - */ - @Nullable - JetType getInType(); + private PropertyAccessorDescriptor getter; + private PropertyAccessorDescriptor setter; + private boolean hasBackingField; + + public PropertyDescriptor( + @NotNull DeclarationDescriptor containingDeclaration, + @NotNull List attributes, + @NotNull String name, + @Nullable JetType inType, + @Nullable JetType outType) { + super(containingDeclaration, attributes, name, inType, outType); + } + + public PropertyAccessorDescriptor getGetter() { + return getter; + } + + public PropertyAccessorDescriptor getSetter() { + return setter; + } + + public boolean hasBackingFiled() { + return hasBackingField; + } + + @NotNull + @Override + public VariableDescriptor substitute(TypeSubstitutor substitutor) { + JetType originalInType = getInType(); + JetType inType = originalInType == null ? null : substitutor.substitute(originalInType, Variance.IN_VARIANCE); + JetType outType = substitutor.substitute(getOutType(), Variance.OUT_VARIANCE); + if (inType == null && outType == null) { + return null; // TODO : tell the user that the property was projected out + } + return new PropertyDescriptor( + getContainingDeclaration(), + getAttributes(), // TODO + getName(), + inType, + outType + ); + } @Override - @SuppressWarnings({"NullableProblems"}) - @NotNull - DeclarationDescriptor getContainingDeclaration(); + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitPropertyDescriptor(this, data); + } } diff --git a/idea/src/org/jetbrains/jet/lang/types/TypeParameterDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/TypeParameterDescriptor.java index 9bbc612cfaa..0a089b661fd 100644 --- a/idea/src/org/jetbrains/jet/lang/types/TypeParameterDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/TypeParameterDescriptor.java @@ -74,6 +74,12 @@ public class TypeParameterDescriptor extends DeclarationDescriptorImpl implement return boundsAsType; } + @NotNull + @Override + public TypeParameterDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO + } + @Override public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitTypeParameterDescriptor(this, data); diff --git a/idea/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java b/idea/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java index e6c04db43d4..66ca5f291c4 100644 --- a/idea/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java +++ b/idea/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java @@ -17,51 +17,71 @@ public class TypeSubstitutor { } } - public static final TypeSubstitutor INSTANCE = new TypeSubstitutor(); + public static TypeSubstitutor create(@NotNull Map substitutionContext) { + return new TypeSubstitutor(substitutionContext); + } - private TypeSubstitutor() {} + public static TypeSubstitutor create(@NotNull JetType context) { + return create(TypeUtils.buildSubstitutionContext(context)); + } - public JetType safeSubstitute(@NotNull JetType context, @NotNull JetType subject, @NotNull Variance howThisTypeIsUsed) { - return safeSubstitute(TypeUtils.buildSubstitutionContext(context), subject, howThisTypeIsUsed); +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + private final @NotNull Map substitutionContext; + + private TypeSubstitutor(@NotNull Map substitutionContext) { + this.substitutionContext = substitutionContext; + } + + public boolean isEmpty() { + return substitutionContext.isEmpty(); } @NotNull - public JetType safeSubstitute(@NotNull Map substitutionContext, @NotNull JetType type, @NotNull Variance howThisTypeIsUsed) { + public JetType safeSubstitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) { + if (isEmpty()) { + return type; + } + try { - return unsafeSubstitute(substitutionContext, type, howThisTypeIsUsed); + return unsafeSubstitute(type, howThisTypeIsUsed); } catch (SubstitutionException e) { return ErrorUtils.createErrorType(e.getMessage()); } } @Nullable - public JetType substitute(@NotNull Map substitutionContext, @NotNull JetType type, @NotNull Variance howThisTypeIsUsed) { + public JetType substitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) { + if (isEmpty()) { + return type; + } + try { - return unsafeSubstitute(substitutionContext, type, howThisTypeIsUsed); + return unsafeSubstitute(type, howThisTypeIsUsed); } catch (SubstitutionException e) { return null; } } @NotNull - private JetType unsafeSubstitute(@NotNull Map substitutionContext, @NotNull JetType type, @NotNull Variance howThisTypeIsUsed) throws SubstitutionException { + private JetType unsafeSubstitute(@NotNull JetType type, @NotNull Variance howThisTypeIsUsed) throws SubstitutionException { TypeConstructor constructor = type.getConstructor(); TypeProjection value = substitutionContext.get(constructor); if (value != null) { assert constructor.getDeclarationDescriptor() instanceof TypeParameterDescriptor; - return substitutionResult(substitutionContext, (TypeParameterDescriptor) constructor.getDeclarationDescriptor(), howThisTypeIsUsed, Variance.INVARIANT, value).getType(); -// + return substitutionResult((TypeParameterDescriptor) constructor.getDeclarationDescriptor(), howThisTypeIsUsed, Variance.INVARIANT, value).getType(); + // if (!allows(howThisTypeIsUsed, value.getProjectionKind())) { // throw new SubstitutionException("!!" + value.toString()); // } // return value.getType(); } - return specializeType(type, substitutionContext, howThisTypeIsUsed); + return specializeType(type, howThisTypeIsUsed); } - private JetType specializeType(JetType subjectType, Map substitutionContext, Variance callSiteVariance) throws SubstitutionException { + private JetType specializeType(JetType subjectType, Variance callSiteVariance) throws SubstitutionException { List newArguments = new ArrayList(); List arguments = subjectType.getArguments(); for (int i = 0, argumentsSize = arguments.size(); i < argumentsSize; i++) { @@ -78,7 +98,7 @@ public class TypeSubstitutor { subjectType.getConstructor(), subjectType.isNullable(), newArguments, - new SubstitutingScope(subjectType.getMemberScope(), substitutionContext)); + new SubstitutingScope(subjectType.getMemberScope(), this)); } @NotNull @@ -102,18 +122,16 @@ public class TypeSubstitutor { return TypeUtils.makeStarProjection(correspondingTypeParameter); } - return substitutionResult(substitutionContext, correspondingTypeParameter, effectiveContextVariance, passedProjectionKind, projectionValue); + return substitutionResult(correspondingTypeParameter, effectiveContextVariance, passedProjectionKind, projectionValue); } return new TypeProjection( passedProjectionKind, specializeType( typeToSubstituteIn, - substitutionContext, effectiveContextVariance)); } private TypeProjection substitutionResult( - Map substitutionContext, TypeParameterDescriptor correspondingTypeParameter, Variance effectiveContextVariance, Variance passedProjectionKind, @@ -154,7 +172,7 @@ public class TypeSubstitutor { // throw new SubstitutionException(""); // TODO : error message // } // - return new TypeProjection(effectiveProjectionKindValue, specializeType(effectiveTypeValue, substitutionContext, effectiveContextVariance)); + return new TypeProjection(effectiveProjectionKindValue, specializeType(effectiveTypeValue, effectiveContextVariance)); } private static Variance asymmetricOr(Variance a, Variance b) { diff --git a/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptor.java index c7fb22bf6cf..c64eb809d0b 100644 --- a/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptor.java @@ -5,7 +5,7 @@ import org.jetbrains.annotations.NotNull; /** * @author abreslav */ -public interface ValueParameterDescriptor extends PropertyDescriptor { +public interface ValueParameterDescriptor extends VariableDescriptor { /** * Returns the 0-based index of the value parameter in the parameter list of its containing function. * diff --git a/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptorImpl.java b/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptorImpl.java index 20cbb4f89d6..e14bf3e438a 100644 --- a/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptorImpl.java +++ b/idea/src/org/jetbrains/jet/lang/types/ValueParameterDescriptorImpl.java @@ -8,7 +8,7 @@ import java.util.List; /** * @author abreslav */ -public class ValueParameterDescriptorImpl extends PropertyDescriptorImpl implements ValueParameterDescriptor { +public class ValueParameterDescriptorImpl extends VariableDescriptorImpl implements ValueParameterDescriptor { private final boolean hasDefaultValue; private final boolean isVararg; private final int index; @@ -53,4 +53,15 @@ public class ValueParameterDescriptorImpl extends PropertyDescriptorImpl impleme public boolean isVararg() { return isVararg; } + + @NotNull + @Override + public VariableDescriptor substitute(TypeSubstitutor substitutor) { + throw new UnsupportedOperationException(); // TODO + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitValueParameterDescriptor(this, data); + } } diff --git a/idea/src/org/jetbrains/jet/lang/types/VariableDescriptor.java b/idea/src/org/jetbrains/jet/lang/types/VariableDescriptor.java new file mode 100644 index 00000000000..e01a962aa8f --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/types/VariableDescriptor.java @@ -0,0 +1,30 @@ +package org.jetbrains.jet.lang.types; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * @author abreslav + */ +public interface VariableDescriptor extends DeclarationDescriptor { + /** + * @return null for write-only variables (i.e. properties), variable value type otherwise + */ + @Nullable + JetType getOutType(); + + /** + * @return null for read-only variables (i.e. val's etc), or the type expected on assignment type otherwise + */ + @Nullable + JetType getInType(); + + @Override + @SuppressWarnings({"NullableProblems"}) + @NotNull + DeclarationDescriptor getContainingDeclaration(); + + @NotNull + @Override + VariableDescriptor substitute(TypeSubstitutor substitutor); +} diff --git a/idea/src/org/jetbrains/jet/lang/types/PropertyDescriptorImpl.java b/idea/src/org/jetbrains/jet/lang/types/VariableDescriptorImpl.java similarity index 73% rename from idea/src/org/jetbrains/jet/lang/types/PropertyDescriptorImpl.java rename to idea/src/org/jetbrains/jet/lang/types/VariableDescriptorImpl.java index 4147cf7e815..ba44c08dd3f 100644 --- a/idea/src/org/jetbrains/jet/lang/types/PropertyDescriptorImpl.java +++ b/idea/src/org/jetbrains/jet/lang/types/VariableDescriptorImpl.java @@ -8,11 +8,11 @@ import java.util.List; /** * @author abreslav */ -public class PropertyDescriptorImpl extends DeclarationDescriptorImpl implements PropertyDescriptor { +public abstract class VariableDescriptorImpl extends DeclarationDescriptorImpl implements VariableDescriptor { private final JetType inType; private final JetType outType; - public PropertyDescriptorImpl( + public VariableDescriptorImpl( @NotNull DeclarationDescriptor containingDeclaration, @NotNull List attributes, @NotNull String name, @@ -35,9 +35,4 @@ public class PropertyDescriptorImpl extends DeclarationDescriptorImpl implements public JetType getInType() { return inType; } - - @Override - public R accept(DeclarationDescriptorVisitor visitor, D data) { - return visitor.visitPropertyDescriptor(this, data); - } } diff --git a/idea/src/org/jetbrains/jet/resolve/DescriptorUtil.java b/idea/src/org/jetbrains/jet/resolve/DescriptorUtil.java index 895fa2beb95..acada12de63 100644 --- a/idea/src/org/jetbrains/jet/resolve/DescriptorUtil.java +++ b/idea/src/org/jetbrains/jet/resolve/DescriptorUtil.java @@ -17,7 +17,7 @@ public class DescriptorUtil { declarationDescriptor.accept( new DeclarationDescriptorVisitor() { @Override - public Void visitPropertyDescriptor(PropertyDescriptor descriptor, StringBuilder builder) { + public Void visitVariableDescriptor(VariableDescriptor descriptor, StringBuilder builder) { JetType outType = descriptor.getOutType(); JetType inType = descriptor.getInType(); String typeString = ""; @@ -39,7 +39,7 @@ public class DescriptorUtil { typeString = inType.toString(); } builder.append(renderName(descriptor)).append(" : ").append(typeString); - return super.visitPropertyDescriptor(descriptor, builder); + return super.visitVariableDescriptor(descriptor, builder); } @Override @@ -50,7 +50,7 @@ public class DescriptorUtil { builder.append("("); for (Iterator iterator = descriptor.getUnsubstitutedValueParameters().iterator(); iterator.hasNext(); ) { ValueParameterDescriptor parameterDescriptor = iterator.next(); - visitPropertyDescriptor(parameterDescriptor, builder); + visitVariableDescriptor(parameterDescriptor, builder); if (iterator.hasNext()) { builder.append(", "); }