azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

name and containingDeclaration pulled up

Browse Source
This commit is contained in:
Andrey Breslav
2013-09-24 15:02:17 -07:00
parent 6bed3cdc59
commit 0d84565570
8 changed files with 109 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractClassDescriptor.java
+83
View File
@@ -0,0 +1,83 @@
package org.jetbrains.jet.lang.descriptors.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
import org.jetbrains.jet.lang.types.*;
import java.util.List;
import java.util.Map;
public abstract class AbstractClassDescriptor implements ClassDescriptor {
protected final Name name;
protected volatile JetType defaultType;
public AbstractClassDescriptor(@NotNull Name name) {
this.name = name;
}
@NotNull
@Override
public Name getName() {
return name;
}
@NotNull
@Override
public DeclarationDescriptor getOriginal() {
return this;
}
protected abstract JetScope getScopeForMemberLookup();
@NotNull
@Override
public JetScope getMemberScope(List<TypeProjection> typeArguments) {
assert typeArguments.size() == getTypeConstructor().getParameters().size() : "Illegal number of type arguments: expected "
+ getTypeConstructor().getParameters().size() + " but was " + typeArguments.size()
+ " for " + getTypeConstructor() + " " + getTypeConstructor().getParameters();
if (typeArguments.isEmpty()) return getScopeForMemberLookup();
List<TypeParameterDescriptor> typeParameters = getTypeConstructor().getParameters();
Map<TypeConstructor, TypeProjection> substitutionContext = SubstitutionUtils.buildSubstitutionContext(typeParameters, typeArguments);
// Unsafe substitutor is OK, because no recursion can hurt us upon a trivial substitution:
// all the types are written explicitly in the code already, they can not get infinite.
// One exception is *-projections, but they need to be handled separately anyways.
TypeSubstitutor substitutor = TypeSubstitutor.createUnsafe(substitutionContext);
return new SubstitutingScope(getScopeForMemberLookup(), substitutor);
}
@NotNull
@Override
public ClassDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
if (substitutor.isEmpty()) {
return this;
}
return new LazySubstitutingClassDescriptor(this, substitutor);
}
@NotNull
@Override
public JetType getDefaultType() {
if (defaultType == null) {
defaultType = TypeUtils.makeUnsubstitutedType(this, getScopeForMemberLookup());
}
return defaultType;
}
@Override
public void acceptVoid(DeclarationDescriptorVisitor<Void, Void> visitor) {
visitor.visitClassDescriptor(this, null);
}
@Override
public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
return visitor.visitClassDescriptor(this, data);
}
}
core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ClassDescriptorBase.java
+8 -59
View File
@@ -17,72 +17,21 @@
package org.jetbrains.jet.lang.descriptors.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.resolve.name.Name;
import java.util.List;
import java.util.Map;
public abstract class ClassDescriptorBase extends AbstractClassDescriptor {
public abstract class ClassDescriptorBase implements ClassDescriptor {
private final DeclarationDescriptor containingDeclaration;
protected volatile JetType defaultType;
@NotNull
@Override
public DeclarationDescriptor getOriginal() {
return this;
}
protected abstract JetScope getScopeForMemberLookup();
@NotNull
@Override
public JetScope getMemberScope(List<TypeProjection> typeArguments) {
assert typeArguments.size() == getTypeConstructor().getParameters().size() : "Illegal number of type arguments: expected "
+ getTypeConstructor().getParameters().size() + " but was " + typeArguments.size()
+ " for " + getTypeConstructor() + " " + getTypeConstructor().getParameters();
if (typeArguments.isEmpty()) return getScopeForMemberLookup();
List<TypeParameterDescriptor> typeParameters = getTypeConstructor().getParameters();
Map<TypeConstructor, TypeProjection> substitutionContext = SubstitutionUtils.buildSubstitutionContext(typeParameters, typeArguments);
// Unsafe substitutor is OK, because no recursion can hurt us upon a trivial substitution:
// all the types are written explicitly in the code already, they can not get infinite.
// One exception is *-projections, but they need to be handled separately anyways.
TypeSubstitutor substitutor = TypeSubstitutor.createUnsafe(substitutionContext);
return new SubstitutingScope(getScopeForMemberLookup(), substitutor);
protected ClassDescriptorBase(@NotNull DeclarationDescriptor containingDeclaration, @NotNull Name name) {
super(name);
this.containingDeclaration = containingDeclaration;
}
@NotNull
@Override
public ClassDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
if (substitutor.isEmpty()) {
return this;
}
return new LazySubstitutingClassDescriptor(this, substitutor);
}
@NotNull
@Override
public JetType getDefaultType() {
if (defaultType == null) {
defaultType = TypeUtils.makeUnsubstitutedType(this, getScopeForMemberLookup());
}
return defaultType;
}
@Override
public void acceptVoid(DeclarationDescriptorVisitor<Void, Void> visitor) {
visitor.visitClassDescriptor(this, null);
}
@Override
public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
return visitor.visitClassDescriptor(this, data);
public DeclarationDescriptor getContainingDeclaration() {
return containingDeclaration;
}
}
core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptor.java
+2 -8
View File
@@ -43,7 +43,7 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite {
public MutableClassDescriptor(@NotNull DeclarationDescriptor containingDeclaration,
@NotNull JetScope outerScope, ClassKind kind, boolean isInner, Name name) {
super(containingDeclaration, kind, isInner);
super(containingDeclaration, name, kind, isInner);
RedeclarationHandler redeclarationHandler = RedeclarationHandler.DO_NOTHING;
@@ -57,7 +57,7 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite {
setUpScopeForInitializers(this);
}
setName(name);
scopeForMemberResolution.addLabeledDeclaration(this);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -128,12 +128,6 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite {
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@Override
public void setName(@NotNull Name name) {
super.setName(name);
scopeForMemberResolution.addLabeledDeclaration(this);
}
@Override
public void createTypeConstructor() {
super.createTypeConstructor();
core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptorLite.java
+2 -21
View File
@@ -60,35 +60,16 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase {
private ReceiverParameterDescriptor implicitReceiver;
private Name name;
private final DeclarationDescriptor containingDeclaration;
public MutableClassDescriptorLite(@NotNull DeclarationDescriptor containingDeclaration,
@NotNull Name name,
@NotNull ClassKind kind,
boolean isInner
) {
this.containingDeclaration = containingDeclaration;
super(containingDeclaration, name);
this.kind = kind;
this.isInner = isInner;
}
@NotNull
@Override
public DeclarationDescriptor getContainingDeclaration() {
return containingDeclaration;
}
@NotNull
@Override
public Name getName() {
return name;
}
public void setName(@NotNull Name name) {
assert this.name == null : this.name;
this.name = name;
}
@NotNull
@Override
public TypeConstructor getTypeConstructor() {