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

Merge branch 'master' of ssh://git.labs.intellij.net/jet

Browse Source
This commit is contained in:
svtk
2011-09-19 12:15:57 +04:00
parent 408c68795d 0dfef593c8
commit e6c871aecc
164 changed files with 5104 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+7 -5
View File
@@ -10,12 +10,8 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.types.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeProjection;
import org.jetbrains.jet.lang.types.Variance;
import org.jetbrains.jet.lexer.JetTokens;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.*;
import org.objectweb.asm.commons.InstructionAdapter;
import org.objectweb.asm.commons.Method;
@@ -101,6 +97,12 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
interfaces.toArray(new String[interfaces.size()])
);
v.visitSource(myClass.getContainingFile().getName(), null);
if(myClass instanceof JetClass) {
AnnotationVisitor annotationVisitor = v.visitAnnotation("Ljet/typeinfo/JetSignature;", true);
annotationVisitor.visit("value", SignatureUtil.classToSignature((JetClass)myClass, state.getBindingContext(), state.getTypeMapper()));
annotationVisitor.visitEnd();
}
}
private String jvmName() {
compiler/backend/src/org/jetbrains/jet/codegen/SignatureUtil.java
+77
View File
@@ -0,0 +1,77 @@
package org.jetbrains.jet.codegen;
import jet.typeinfo.TypeInfoVariance;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.psi.JetClass;
import org.jetbrains.jet.lang.psi.JetDelegationSpecifier;
import org.jetbrains.jet.lang.psi.JetTypeParameter;
import org.jetbrains.jet.lang.psi.JetTypeReference;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.JavaClassDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeProjection;
import org.jetbrains.jet.lang.types.Variance;
import org.objectweb.asm.Type;
import java.util.List;
/**
* @author alex.tkachman
*/
public class SignatureUtil {
public static String classToSignature(JetClass type, BindingContext bindingContext, JetTypeMapper typeMapper) {
StringBuilder sb = new StringBuilder();
genTypeParams(type, sb);
List<JetDelegationSpecifier> delegationSpecifiers = type.getDelegationSpecifiers();
for (JetDelegationSpecifier specifier : delegationSpecifiers) {
JetTypeReference typeReference = specifier.getTypeReference();
JetType jetType = bindingContext.get(BindingContext.TYPE, typeReference);
genJetType(sb, jetType, typeMapper);
}
return sb.toString();
}
private static void genJetType(StringBuilder sb, JetType jetType, JetTypeMapper typeMapper) {
DeclarationDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
if(descriptor instanceof ClassDescriptor) {
JetType defaultType = ((ClassDescriptor) descriptor).getDefaultType();
org.objectweb.asm.Type type = typeMapper.mapType(defaultType, OwnerKind.IMPLEMENTATION);
if(JetTypeMapper.isPrimitive(type)) {
type = JetTypeMapper.boxType(type);
}
sb.append(type.getDescriptor());
}
else {
sb.append("T").append(descriptor.getName()).append(";");
}
if(!jetType.getArguments().isEmpty()) {
sb.append("<");
for (TypeProjection typeProjection : jetType.getArguments()) {
if(typeProjection.getProjectionKind() == Variance.IN_VARIANCE)
sb.append("in ");
if(typeProjection.getProjectionKind() == Variance.OUT_VARIANCE)
sb.append("out ");
genJetType(sb, typeProjection.getType(), typeMapper);
}
sb.append(">");
}
if(jetType.isNullable())
sb.append("?");
}
private static void genTypeParams(JetClass type, StringBuilder sb) {
List<JetTypeParameter> parameters = type.getTypeParameterList().getParameters();
for(JetTypeParameter param : parameters) {
sb.append("T");
Variance variance = param.getVariance();
if(variance == Variance.IN_VARIANCE)
sb.append("in ");
else if(variance == Variance.OUT_VARIANCE)
sb.append("out ");
sb.append(param.getName());
sb.append(";");
}
}
}
compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java
+1 -1
View File
@@ -7,7 +7,7 @@ import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.search.ProjectScope;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetStandardLibrary;
import org.jetbrains.jet.lang.types.TypeProjection;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java
+2 -2
View File
@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.resolve.java;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.SubstitutingScope;
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.Collections;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java
+12 -5
View File
@@ -5,11 +5,12 @@ import com.google.common.collect.Sets;
import com.intellij.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
@@ -64,6 +65,7 @@ public class JavaClassMembersScope implements JetScope {
return classifierDescriptor;
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
if (allDescriptors == null) {
@@ -123,7 +125,7 @@ public class JavaClassMembersScope implements JetScope {
return null;
}
return semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor((ClassDescriptor) containingDeclaration, field);
return semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor(containingDeclaration, field);
}
@NotNull
@@ -149,7 +151,12 @@ public class JavaClassMembersScope implements JetScope {
@NotNull
@Override
public JetType getThisType() {
return null;
public ReceiverDescriptor getImplicitReceiver() {
throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
}
@Override
public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDefaultImports.java
+1 -1
View File
@@ -4,7 +4,7 @@ import com.intellij.openapi.project.Project;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.ImportingStrategy;
import org.jetbrains.jet.lang.resolve.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
/**
* @author abreslav
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java
+1 -1
View File
@@ -4,7 +4,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.AbstractNamespaceDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.List;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
+1 -1
View File
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.resolve.java;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.JetScopeImpl;
import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
/**
* @author abreslav
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java
+1 -1
View File
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeProjection;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java
+2 -2
View File
@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.SubstitutingScope;
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.Collection;
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java
+7 -8
View File
@@ -5,16 +5,15 @@ import com.google.common.collect.HashBiMap;
import com.google.common.collect.Maps;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.WritableScope;
import org.jetbrains.jet.lang.resolve.WritableScopeImpl;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionCallableReceiver;
import org.jetbrains.jet.lang.types.*;
import java.util.*;
import static org.jetbrains.jet.lang.types.TypeSubstitutor.TypeSubstitution;
/**
* @author abreslav
*/
@@ -97,10 +96,10 @@ public class FunctionDescriptorUtil {
@NotNull
public static JetScope getFunctionInnerScope(@NotNull JetScope outerScope, @NotNull FunctionDescriptor descriptor, @NotNull BindingTrace trace) {
WritableScope parameterScope = new WritableScopeImpl(outerScope, descriptor, trace).setDebugName("Function inner scope");
WritableScope parameterScope = new WritableScopeImpl(outerScope, descriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Function inner scope");
JetType receiverType = descriptor.getReceiverType();
if (receiverType != null) {
parameterScope.setThisType(receiverType);
parameterScope.setImplicitReceiver(new ExtensionCallableReceiver(descriptor));
}
for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
parameterScope.addTypeParameterDescriptor(typeParameter);
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java
+2 -2
View File
@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.descriptors;
import com.google.common.collect.Lists;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.SubstitutingScope;
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.Collection;
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java
+10 -4
View File
@@ -6,6 +6,11 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.resolve.DescriptorRenderer;
@@ -40,9 +45,10 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
public MutableClassDescriptor(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor containingDeclaration, @NotNull JetScope outerScope, ClassKind kind) {
super(containingDeclaration);
this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, trace).setDebugName("MemberLookup");
this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, trace).setDebugName("SupertypeResolution");
this.scopeForMemberResolution = new WritableScopeImpl(scopeForSupertypeResolution, this, trace).setDebugName("MemberResolution");
TraceBasedRedeclarationHandler redeclarationHandler = new TraceBasedRedeclarationHandler(trace);
this.scopeForMemberLookup = new WritableScopeImpl(JetScope.EMPTY, this, redeclarationHandler).setDebugName("MemberLookup");
this.scopeForSupertypeResolution = new WritableScopeImpl(outerScope, this, redeclarationHandler).setDebugName("SupertypeResolution");
this.scopeForMemberResolution = new WritableScopeImpl(scopeForSupertypeResolution, this, redeclarationHandler).setDebugName("MemberResolution");
this.kind = kind;
}
@@ -159,7 +165,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
getName(),
typeParameters,
supertypes);
scopeForMemberResolution.setThisType(getDefaultType());
scopeForMemberResolution.setImplicitReceiver(new ClassReceiver(this));
for (FunctionDescriptor functionDescriptor : constructors.getFunctionDescriptors()) {
((ConstructorDescriptorImpl) functionDescriptor).setReturnType(getDefaultType());
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptor.java
+1 -1
View File
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.NamespaceType;
/**
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java
+1 -1
View File
@@ -3,7 +3,7 @@ package org.jetbrains.jet.lang.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import java.util.List;
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java
+2 -2
View File
@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.descriptors;
import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.LazyScopeAdapter;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.resolve.DescriptorRenderer;
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement1.java
+2 -4
View File
@@ -1,9 +1,7 @@
package org.jetbrains.jet.lang.diagnostics;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
/**
@@ -29,11 +27,11 @@ public abstract class DiagnosticFactoryWithPsiElement1<T extends PsiElement, A>
@NotNull
public Diagnostic on(@NotNull T element, @NotNull ASTNode node, @NotNull A argument) {
return new DiagnosticWithPsiElement<T>(this, severity, makeMessage(argument), element, node.getTextRange());
return new DiagnosticWithPsiElementImpl<T>(this, severity, makeMessage(argument), element, node.getTextRange());
}
@NotNull
public Diagnostic on(@NotNull T element, @NotNull PsiElement psiElement, @NotNull A argument) {
return new DiagnosticWithPsiElement<T>(this, severity, makeMessage(argument), element, psiElement.getTextRange());
return new DiagnosticWithPsiElementImpl<T>(this, severity, makeMessage(argument), element, psiElement.getTextRange());
}
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticFactoryWithPsiElement2.java
+1 -1
View File
@@ -33,6 +33,6 @@ public abstract class DiagnosticFactoryWithPsiElement2<T extends PsiElement, A,
@NotNull
public Diagnostic on(@NotNull T element, @NotNull ASTNode node, @NotNull A a, @NotNull B b) {
return new DiagnosticWithPsiElement<T>(this, severity, makeMessage(a, b), element, node.getTextRange());
return new DiagnosticWithPsiElementImpl<T>(this, severity, makeMessage(a, b), element, node.getTextRange());
}
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticUtils.java
+7 -2
View File
@@ -4,7 +4,6 @@ import com.intellij.lang.ASTNode;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
@@ -42,8 +41,14 @@ public class DiagnosticUtils {
return closestPsiElement.getContainingFile();
}
@NotNull
public static String atLocation(@NotNull PsiFile file, @NotNull TextRange textRange) {
Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file);
Document document = file.getViewProvider().getDocument();//PsiDocumentManager.getInstance(file.getProject()).getDocument(file);
return atLocation(file, textRange, document);
}
@NotNull
public static String atLocation(PsiFile file, TextRange textRange, Document document) {
int offset = textRange.getStartOffset();
VirtualFile virtualFile = file.getVirtualFile();
String pathSuffix = virtualFile == null ? "" : " in " + virtualFile.getPath();
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElement.java
+3 -18
View File
@@ -1,27 +1,12 @@
package org.jetbrains.jet.lang.diagnostics;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
/**
* @author svtk
* @author abreslav
*/
public class DiagnosticWithPsiElement<T extends PsiElement> extends GenericDiagnostic {
private final T psiElement;
public DiagnosticWithPsiElement(DiagnosticFactory factory, Severity severity, String message, T psiElement) {
this(factory, severity, message, psiElement, psiElement.getTextRange());
}
public DiagnosticWithPsiElement(DiagnosticFactory factory, Severity severity, String message, T psiElement, @NotNull TextRange textRange) {
super(factory, severity, message, psiElement.getContainingFile(), textRange);
this.psiElement = psiElement;
}
public interface DiagnosticWithPsiElement<T extends PsiElement> extends DiagnosticWithTextRange {
@NotNull
public T getPsiElement() {
return psiElement;
}
T getPsiElement();
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/DiagnosticWithPsiElementImpl.java
+27
View File
@@ -0,0 +1,27 @@
package org.jetbrains.jet.lang.diagnostics;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
/**
* @author svtk
*/
public class DiagnosticWithPsiElementImpl<T extends PsiElement> extends GenericDiagnostic implements DiagnosticWithPsiElement<T> {
private final T psiElement;
public DiagnosticWithPsiElementImpl(DiagnosticFactory factory, Severity severity, String message, T psiElement) {
this(factory, severity, message, psiElement, psiElement.getTextRange());
}
public DiagnosticWithPsiElementImpl(DiagnosticFactory factory, Severity severity, String message, T psiElement, @NotNull TextRange textRange) {
super(factory, severity, message, psiElement.getContainingFile(), textRange);
this.psiElement = psiElement;
}
@Override
@NotNull
public T getPsiElement() {
return psiElement;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/ParameterizedDiagnosticFactory3.java
+1 -1
View File
@@ -46,6 +46,6 @@ public class ParameterizedDiagnosticFactory3<A, B, C> extends DiagnosticFactoryW
@NotNull
public Diagnostic on(@NotNull PsiElement element, @NotNull A a, @NotNull B b, @NotNull C c) {
return new DiagnosticWithPsiElement<PsiElement>(this, severity, makeMessage(a, b, c), element);
return new DiagnosticWithPsiElementImpl<PsiElement>(this, severity, makeMessage(a, b, c), element);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnostic.java
+65 -32
View File
@@ -1,46 +1,79 @@
package org.jetbrains.jet.lang.diagnostics;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.resolve.BindingContext;
import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
/**
* @author abreslav
*/
public class RedeclarationDiagnostic implements Diagnostic {
* @author abreslav
*/
public interface RedeclarationDiagnostic extends DiagnosticWithPsiElement<PsiElement> {
public class SimpleRedeclarationDiagnostic extends DiagnosticWithPsiElementImpl<PsiElement> implements RedeclarationDiagnostic {
private final DeclarationDescriptor a;
private final DeclarationDescriptor b;
public RedeclarationDiagnostic(DeclarationDescriptor a, DeclarationDescriptor b) {
this.a = a;
this.b = b;
public SimpleRedeclarationDiagnostic(@NotNull PsiElement psiElement) {
super(RedeclarationDiagnosticFactory.INSTANCE, ERROR, "Redeclaration", psiElement);
}
}
public DeclarationDescriptor getA() {
return a;
public class RedeclarationDiagnosticWithDeferredResolution implements RedeclarationDiagnostic {
private final DeclarationDescriptor duplicatingDescriptor;
private final BindingContext contextToResolveToDeclaration;
private PsiElement element;
public RedeclarationDiagnosticWithDeferredResolution(@NotNull DeclarationDescriptor duplicatingDescriptor, @NotNull BindingContext contextToResolveToDeclaration) {
this.duplicatingDescriptor = duplicatingDescriptor;
this.contextToResolveToDeclaration = contextToResolveToDeclaration;
}
private PsiElement resolve() {
if (element == null) {
element = contextToResolveToDeclaration.get(BindingContext.DESCRIPTOR_TO_DECLARATION, duplicatingDescriptor);
assert element != null : "No element for descriptor: " + duplicatingDescriptor;
}
return element;
}
@NotNull
@Override
public PsiElement getPsiElement() {
return resolve();
}
@NotNull
@Override
public TextRange getTextRange() {
return resolve().getTextRange();
}
@NotNull
@Override
public PsiFile getPsiFile() {
return resolve().getContainingFile();
}
@NotNull
@Override
public DiagnosticFactory getFactory() {
return Errors.REDECLARATION;
}
@NotNull
@Override
public String getMessage() {
return "Redeclaration";
}
@NotNull
@Override
public Severity getSeverity() {
return ERROR;
}
}
public DeclarationDescriptor getB() {
return b;
}
@NotNull
@Override
public DiagnosticFactory getFactory() {
return RedeclarationDiagnosticFactory.INSTANCE;
}
@NotNull
@Override
public String getMessage() {
return "Redeclaration";
}
@NotNull
@Override
public Severity getSeverity() {
return ERROR;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/RedeclarationDiagnosticFactory.java
+18 -11
View File
@@ -1,33 +1,40 @@
package org.jetbrains.jet.lang.diagnostics;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.psi.JetNamedDeclaration;
import org.jetbrains.jet.lang.resolve.BindingContext;
/**
* @author abreslav
*/
public class RedeclarationDiagnosticFactory implements DiagnosticFactory {
public class RedeclarationDiagnosticFactory extends AbstractDiagnosticFactory {
public static final RedeclarationDiagnosticFactory INSTANCE = new RedeclarationDiagnosticFactory();
public RedeclarationDiagnosticFactory() {}
public RedeclarationDiagnostic on(DeclarationDescriptor a, DeclarationDescriptor b) {
return new RedeclarationDiagnostic(a, b);
public RedeclarationDiagnostic on(@NotNull PsiElement duplicatingElement) {
return new RedeclarationDiagnostic.SimpleRedeclarationDiagnostic(duplicatingElement);
}
public Diagnostic on(DeclarationDescriptor duplicatingDescriptor, BindingContext contextToResolveToDeclaration) {
return new RedeclarationDiagnostic.RedeclarationDiagnosticWithDeferredResolution(duplicatingDescriptor, contextToResolveToDeclaration);
}
@NotNull
@Override
public TextRange getTextRange(@NotNull Diagnostic diagnostic) {
throw new UnsupportedOperationException(); // TODO
}
@NotNull
@Override
public PsiFile getPsiFile(@NotNull Diagnostic diagnostic) {
throw new UnsupportedOperationException(); // TODO
PsiElement redeclaration = ((RedeclarationDiagnostic) diagnostic).getPsiElement();
if (redeclaration instanceof JetNamedDeclaration) {
PsiElement nameIdentifier = ((JetNamedDeclaration) redeclaration).getNameIdentifier();
if (nameIdentifier != null) {
return nameIdentifier.getTextRange();
}
}
return redeclaration.getTextRange();
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/SimpleDiagnosticFactoryWithPsiElement.java
+1 -1
View File
@@ -18,7 +18,7 @@ public abstract class SimpleDiagnosticFactoryWithPsiElement<T extends PsiElement
@NotNull
public Diagnostic on(@NotNull T element, @NotNull ASTNode node) {
return new DiagnosticWithPsiElement<T>(this, severity, message, element, node.getTextRange());
return new DiagnosticWithPsiElementImpl<T>(this, severity, message, element, node.getTextRange());
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java
+1 -1
View File
@@ -8,7 +8,7 @@ import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
/**
* @author abreslav
*/
public class UnresolvedReferenceDiagnostic extends DiagnosticWithPsiElement<JetReferenceExpression> {
public class UnresolvedReferenceDiagnostic extends DiagnosticWithPsiElementImpl<JetReferenceExpression> {
public UnresolvedReferenceDiagnostic(JetReferenceExpression referenceExpression) {
super(Errors.UNRESOLVED_REFERENCE, ERROR, "Unresolved reference", referenceExpression);
compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetExpressionParsing.java
+2
View File
@@ -106,7 +106,9 @@ public class JetExpressionParsing extends AbstractJetParsing {
COLON_AS(COLON, AS_KEYWORD, AS_SAFE) {
@Override
public JetNodeType parseRightHandSide(IElementType operation, JetExpressionParsing parser) {
parser.myBuilder.disableJoiningComplexTokens();
parser.myJetParsing.parseTypeRef();
parser.myBuilder.enableJoiningComplexTokens();
return BINARY_WITH_TYPE;
}
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteral.java
+17
View File
@@ -3,6 +3,7 @@ package org.jetbrains.jet.lang.psi;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lexer.JetTokens;
/**
@@ -36,4 +37,20 @@ public class JetFunctionLiteral extends JetFunction {
public JetBlockExpression getBodyExpression() {
return (JetBlockExpression) super.getBodyExpression();
}
@NotNull
public ASTNode getOpenBraceNode() {
return getNode().findChildByType(JetTokens.LBRACE);
}
@Nullable
@IfNotParsed
public ASTNode getClosingBraceNode() {
return getNode().findChildByType(JetTokens.RBRACE);
}
@Nullable
public ASTNode getArrowNode() {
return getNode().findChildByType(JetTokens.DOUBLE_ARROW);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionLiteralExpression.java
+3
View File
@@ -2,7 +2,9 @@ package org.jetbrains.jet.lang.psi;
import com.intellij.lang.ASTNode;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.JetNodeTypes;
import org.jetbrains.jet.lexer.JetTokens;
/**
* @author max
@@ -47,4 +49,5 @@ public class JetFunctionLiteralExpression extends JetExpression implements JetDe
public JetElement asElement() {
return this;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java
+11 -3
View File
@@ -2,9 +2,11 @@ package org.jetbrains.jet.lang.resolve;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.Collection;
import java.util.List;
/**
* @author abreslav
@@ -15,8 +17,13 @@ public abstract class AbstractScopeAdapter implements JetScope {
@NotNull
@Override
public JetType getThisType() {
return getWorkerScope().getThisType();
public ReceiverDescriptor getImplicitReceiver() {
return getWorkerScope().getImplicitReceiver();
}
@Override
public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
getWorkerScope().getImplicitReceiversHierarchy(result);
}
@NotNull
@@ -62,6 +69,7 @@ public abstract class AbstractScopeAdapter implements JetScope {
return getWorkerScope().getDeclarationDescriptorForUnqualifiedThis();
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
return getWorkerScope().getAllDescriptors();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java
+4 -1
View File
@@ -18,6 +18,9 @@ import org.jetbrains.jet.lang.diagnostics.*;
import org.jetbrains.jet.lang.psi.JetDeclaration;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetNamespace;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import java.util.Collections;
@@ -69,7 +72,7 @@ public class AnalyzingUtils {
JetScope libraryScope = semanticServices.getStandardLibrary().getLibraryScope();
ModuleDescriptor owner = new ModuleDescriptor("<module>");
final WritableScope scope = new WritableScopeImpl(libraryScope, owner, bindingTraceContext).setDebugName("Root scope in analyzeNamespace");
final WritableScope scope = new WritableScopeImpl(libraryScope, owner, new TraceBasedRedeclarationHandler(bindingTraceContext)).setDebugName("Root scope in analyzeNamespace");
importingStrategy.addImports(project, semanticServices, bindingTraceContext, scope);
TopDownAnalyzer.process(semanticServices, bindingTraceContext, scope, new NamespaceLike.Adapter(owner) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java
+1
View File
@@ -10,6 +10,7 @@ import org.jetbrains.jet.lang.psi.JetAnnotationEntry;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetModifierList;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.JetTypeInferrer;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
+3 -1
View File
@@ -7,6 +7,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.diagnostics.Diagnostic;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.util.slicedmap.*;
@@ -32,7 +33,8 @@ public interface BindingContext {
WritableSlice<JetExpression, JetScope> RESOLUTION_SCOPE = Slices.createSimpleSlice("RESOLUTION_SCOPE");
WritableSlice<JetExpression, Boolean> VARIABLE_REASSIGNMENT = Slices.createSimpleSetSlice("VARIABLE_REASSIGNMENT");
WritableSlice<JetExpression, DeclarationDescriptor> VARIABLE_ASSIGNMENT = Slices.createSimpleSlice("VARIABLE_ASSIGNMENT");
WritableSlice<ValueParameterDescriptor, Boolean> AUTO_CREATED_IT = Slices.createSimpleSetSlice("AUTO_CREATED_IT");
WritableSlice<JetExpression, DeclarationDescriptor> VARIABLE_ASSIGNMENT = Slices.createSimpleSlice("VARIABLE_ASSIGNMENT");
WritableSlice<JetExpression, Boolean> PROCESSED = Slices.createSimpleSetSlice("PROCESSED");
WritableSlice<JetElement, Boolean> STATEMENT = Slices.createRemovableSetSlice("STATEMENT");
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
+10 -5
View File
@@ -10,6 +10,11 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionCallableReceiver;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.util.slicedmap.WritableSlice;
@@ -500,12 +505,12 @@ public class BodyResolver {
@NotNull
private JetScope getInnerScopeForConstructor(@NotNull ConstructorDescriptor descriptor, @NotNull JetScope declaringScope, boolean primary) {
WritableScope constructorScope = new WritableScopeImpl(declaringScope, declaringScope.getContainingDeclaration(), context.getTrace()).setDebugName("Inner scope for constructor");
WritableScope constructorScope = new WritableScopeImpl(declaringScope, declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Inner scope for constructor");
for (PropertyDescriptor propertyDescriptor : ((MutableClassDescriptor) descriptor.getContainingDeclaration()).getProperties()) {
constructorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor);
}
constructorScope.setThisType(descriptor.getContainingDeclaration().getDefaultType());
// constructorScope.setImplicitReceiver(new ClassReceiver(descriptor.getContainingDeclaration()));
for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) {
JetParameter parameter = (JetParameter) context.getTrace().getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, valueParameterDescriptor);
@@ -567,13 +572,13 @@ public class BodyResolver {
}
private JetScope getPropertyDeclarationInnerScope(@NotNull JetScope outerScope, @NotNull PropertyDescriptor propertyDescriptor) {
WritableScopeImpl result = new WritableScopeImpl(outerScope, propertyDescriptor, context.getTrace()).setDebugName("Property declaration inner scope");
WritableScopeImpl result = new WritableScopeImpl(outerScope, propertyDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Property declaration inner scope");
for (TypeParameterDescriptor typeParameterDescriptor : propertyDescriptor.getTypeParameters()) {
result.addTypeParameterDescriptor(typeParameterDescriptor);
}
JetType receiverType = propertyDescriptor.getReceiverType();
if (receiverType != null) {
result.setThisType(receiverType);
result.setImplicitReceiver(new ExtensionCallableReceiver(propertyDescriptor));
}
return result;
}
@@ -581,7 +586,7 @@ public class BodyResolver {
private void resolvePropertyAccessors(JetProperty property, PropertyDescriptor propertyDescriptor, JetScope declaringScope) {
BindingTraceAdapter fieldAccessTrackingTrace = createFieldTrackingTrace(propertyDescriptor);
WritableScope accessorScope = new WritableScopeImpl(getPropertyDeclarationInnerScope(declaringScope, propertyDescriptor), declaringScope.getContainingDeclaration(), context.getTrace()).setDebugName("Accessor scope");
WritableScope accessorScope = new WritableScopeImpl(getPropertyDeclarationInnerScope(declaringScope, propertyDescriptor), declaringScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Accessor scope");
accessorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor);
JetPropertyAccessor getter = property.getGetter();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java
+6 -3
View File
@@ -17,6 +17,9 @@ import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lexer.JetTokens;
@@ -142,7 +145,7 @@ public class ClassDescriptorResolver {
annotationResolver.resolveAnnotations(scope, function.getModifierList()),
JetPsiUtil.safeName(function.getName())
);
WritableScope innerScope = new WritableScopeImpl(scope, functionDescriptor, trace).setDebugName("Function descriptor header scope");
WritableScope innerScope = new WritableScopeImpl(scope, functionDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Function descriptor header scope");
innerScope.addLabeledDeclaration(functionDescriptor);
List<TypeParameterDescriptor> typeParameterDescriptors = resolveTypeParameters(functionDescriptor, innerScope, function.getTypeParameters());
@@ -451,7 +454,7 @@ public class ClassDescriptorResolver {
typeParameterDescriptors = Collections.emptyList();
}
else {
WritableScope writableScope = new WritableScopeImpl(scope, containingDeclaration, trace).setDebugName("Scope with type parameters of a property");
WritableScope writableScope = new WritableScopeImpl(scope, containingDeclaration, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with type parameters of a property");
typeParameterDescriptors = resolveTypeParameters(containingDeclaration, writableScope, typeParameters);
resolveGenericBounds(property, writableScope, typeParameterDescriptors);
scopeWithTypeParameters = writableScope;
@@ -659,7 +662,7 @@ public class ClassDescriptorResolver {
typeParameters,
resolveValueParameters(
constructorDescriptor,
new WritableScopeImpl(scope, classDescriptor, trace).setDebugName("Scope with value parameters of a constructor"),
new WritableScopeImpl(scope, classDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with value parameters of a constructor"),
valueParameters),
Modality.FINAL);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java
+2
View File
@@ -4,6 +4,8 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import java.util.List;
import java.util.Map;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportingStrategy.java
+1
View File
@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve;
import com.intellij.openapi.project.Project;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
/**
* @author abreslav
compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetModuleUtil.java
+1
View File
@@ -1,6 +1,7 @@
package org.jetbrains.jet.lang.resolve;
import org.jetbrains.jet.lang.psi.JetElement;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.NamespaceType;
/**
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
+2
View File
@@ -5,6 +5,8 @@ import com.google.common.collect.Sets;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import java.util.Map;
import java.util.Set;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
+2
View File
@@ -5,6 +5,8 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import java.util.Collections;
import java.util.List;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TraceBasedRedeclarationHandler.java
+35
View File
@@ -0,0 +1,35 @@
package org.jetbrains.jet.lang.resolve;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
import static org.jetbrains.jet.lang.diagnostics.Errors.REDECLARATION;
/**
* @author abreslav
*/
public class TraceBasedRedeclarationHandler implements RedeclarationHandler {
private final BindingTrace trace;
public TraceBasedRedeclarationHandler(@NotNull BindingTrace trace) {
this.trace = trace;
}
@Override
public void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
report(first);
report(second);
}
private void report(DeclarationDescriptor first) {
PsiElement firstElement = trace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, first);
if (firstElement != null) {
trace.report(REDECLARATION.on(firstElement));
}
else {
trace.report(REDECLARATION.on(first, trace.getBindingContext()));
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+5 -2
View File
@@ -11,6 +11,9 @@ import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lexer.JetTokens;
@@ -71,13 +74,13 @@ public class TypeHierarchyResolver {
Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
name
);
namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, context.getTrace()).setDebugName("Namespace member scope"));
namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"));
owner.addNamespace(namespaceDescriptor);
context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
}
context.getNamespaceDescriptors().put(namespace, namespaceDescriptor);
WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), context.getTrace());
WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace()));
context.getNamespaceScopes().put(namespace, namespaceScope);
processImports(namespace, namespaceScope, outerScope);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
+2
View File
@@ -9,6 +9,8 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
import org.jetbrains.jet.lang.types.*;
import java.util.ArrayList;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
+19 -40
View File
@@ -12,9 +12,9 @@ import org.jetbrains.jet.lang.JetSemanticServices;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.inference.ConstraintSystem;
import org.jetbrains.jet.resolve.DescriptorRenderer;
import java.util.*;
@@ -355,6 +355,7 @@ public class CallResolver {
if (error) {
failedCandidates.add(candidate);
checkTypesWithNoCallee(temporaryTrace, scope, task.getTypeArguments(), task.getValueArguments(), task.getFunctionLiteralArguments());
continue;
}
@@ -490,7 +491,7 @@ public class CallResolver {
}
}
private <Descriptor extends CallableDescriptor> Function<ValueParameterDescriptor, ValueParameterDescriptor> createMapFunction(Descriptor substitutedFunctionDescriptor) {
private <D extends CallableDescriptor> Function<ValueParameterDescriptor, ValueParameterDescriptor> createMapFunction(D substitutedFunctionDescriptor) {
assert substitutedFunctionDescriptor != null;
final Map<ValueParameterDescriptor, ValueParameterDescriptor> parameterMap = Maps.newHashMap();
for (ValueParameterDescriptor valueParameterDescriptor : substitutedFunctionDescriptor.getValueParameters()) {
@@ -505,7 +506,7 @@ public class CallResolver {
};
}
private <Descriptor extends CallableDescriptor> boolean checkReceiver(ResolutionTask<Descriptor> task, TracingStrategy tracing, Descriptor candidate, TemporaryBindingTrace temporaryTrace) {
private <D extends CallableDescriptor> boolean checkReceiver(ResolutionTask<D> task, TracingStrategy tracing, D candidate, TemporaryBindingTrace temporaryTrace) {
if (!checkReceiverAbsence(task, tracing, candidate, temporaryTrace)) return false;
JetType receiverType = task.getReceiverType();
JetType candidateReceiverType = candidate.getReceiverType();
@@ -518,7 +519,7 @@ public class CallResolver {
return true;
}
private <Descriptor extends CallableDescriptor> boolean checkReceiverAbsence(ResolutionTask<Descriptor> task, TracingStrategy tracing, Descriptor candidate, TemporaryBindingTrace temporaryTrace) {
private <D extends CallableDescriptor> boolean checkReceiverAbsence(ResolutionTask<D> task, TracingStrategy tracing, D candidate, TemporaryBindingTrace temporaryTrace) {
JetType receiverType = task.getReceiverType();
JetType candidateReceiverType = candidate.getReceiverType();
if (receiverType != null) {
@@ -535,26 +536,26 @@ public class CallResolver {
}
@NotNull
private <Descriptor extends CallableDescriptor> OverloadResolutionResult<Descriptor> computeResultAndReportErrors(BindingTrace trace, TracingStrategy tracing, Map<Descriptor, Descriptor> successfulCandidates, Set<Descriptor> failedCandidates, Set<Descriptor> dirtyCandidates, Map<Descriptor, TemporaryBindingTrace> traces) {
private <D extends CallableDescriptor> OverloadResolutionResult<D> computeResultAndReportErrors(BindingTrace trace, TracingStrategy tracing, Map<D, D> successfulCandidates, Set<D> failedCandidates, Set<D> dirtyCandidates, Map<D, TemporaryBindingTrace> traces) {
// TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific
if (successfulCandidates.size() > 0) {
if (successfulCandidates.size() != 1) {
Map<Descriptor, Descriptor> cleanCandidates = Maps.newLinkedHashMap(successfulCandidates);
Map<D, D> cleanCandidates = Maps.newLinkedHashMap(successfulCandidates);
cleanCandidates.keySet().removeAll(dirtyCandidates);
if (cleanCandidates.isEmpty()) {
cleanCandidates = successfulCandidates;
}
Descriptor maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, false);
D maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, false);
if (maximallySpecific != null) {
return OverloadResolutionResult.success(maximallySpecific);
}
Descriptor maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, true);
D maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, true);
if (maximallySpecificGenericsDiscriminated != null) {
return OverloadResolutionResult.success(maximallySpecificGenericsDiscriminated);
}
Set<Descriptor> noOverrides = filterOverrides(successfulCandidates.keySet());
Set<D> noOverrides = filterOverrides(successfulCandidates.keySet());
if (dirtyCandidates.isEmpty()) {
// tracing.reportOverallResolutionError(trace, "Overload resolution ambiguity: "
// + makeErrorMessageForMultipleDescriptors(noOverrides));
@@ -566,9 +567,9 @@ public class CallResolver {
return OverloadResolutionResult.ambiguity(noOverrides);
}
else {
Map.Entry<Descriptor, Descriptor> entry = successfulCandidates.entrySet().iterator().next();
Descriptor functionDescriptor = entry.getKey();
Descriptor result = entry.getValue();
Map.Entry<D, D> entry = successfulCandidates.entrySet().iterator().next();
D functionDescriptor = entry.getKey();
D result = entry.getValue();
TemporaryBindingTrace temporaryTrace = traces.get(functionDescriptor);
temporaryTrace.commit();
@@ -577,7 +578,7 @@ public class CallResolver {
}
else if (!failedCandidates.isEmpty()) {
if (failedCandidates.size() != 1) {
Set<Descriptor> noOverrides = filterOverrides(failedCandidates);
Set<D> noOverrides = filterOverrides(failedCandidates);
if (noOverrides.size() != 1) {
// tracing.reportOverallResolutionError(trace, "None of the following functions can be called with the arguments supplied: "
// + makeErrorMessageForMultipleDescriptors(noOverrides));
@@ -587,7 +588,7 @@ public class CallResolver {
}
failedCandidates = noOverrides;
}
Descriptor functionDescriptor = failedCandidates.iterator().next();
D functionDescriptor = failedCandidates.iterator().next();
TemporaryBindingTrace temporaryTrace = traces.get(functionDescriptor);
temporaryTrace.commit();
return OverloadResolutionResult.singleFailedCandidate(failedCandidates.iterator().next());
@@ -598,19 +599,11 @@ public class CallResolver {
}
}
private <Descriptor extends CallableDescriptor> StringBuilder makeErrorMessageForMultipleDescriptors(Set<Descriptor> candidates) {
StringBuilder stringBuilder = new StringBuilder("\n");
for (Descriptor functionDescriptor : candidates) {
stringBuilder.append(DescriptorRenderer.TEXT.render(functionDescriptor)).append("\n");
}
return stringBuilder;
}
private <Descriptor extends CallableDescriptor> Set<Descriptor> filterOverrides(Set<Descriptor> candidateSet) {
Set<Descriptor> candidates = Sets.newLinkedHashSet();
private <D extends CallableDescriptor> Set<D> filterOverrides(Set<D> candidateSet) {
Set<D> candidates = Sets.newLinkedHashSet();
outerLoop:
for (Descriptor me : candidateSet) {
for (Descriptor other : candidateSet) {
for (D me : candidateSet) {
for (D other : candidateSet) {
if (OverloadingConflictResolver.overrides(other, me)) {
continue outerLoop;
}
@@ -718,18 +711,6 @@ public class CallResolver {
return found;
}
private OverloadResolutionResult<FunctionDescriptor> listToOverloadResolutionResult(List<FunctionDescriptor> result) {
if (result.isEmpty()) {
return OverloadResolutionResult.nameNotFound();
}
else if (result.size() == 1) {
return OverloadResolutionResult.success(result.get(0));
}
else {
return OverloadResolutionResult.ambiguity(result);
}
}
private boolean findExtensionFunctions(Collection<FunctionDescriptor> candidates, JetType receiverType, List<JetType> parameterTypes, List<FunctionDescriptor> result) {
boolean found = false;
for (FunctionDescriptor functionDescriptor : candidates) {
@@ -755,7 +736,6 @@ public class CallResolver {
return true;
}
private static TaskPrioritizer<FunctionDescriptor> FUNCTION_TASK_PRIORITIZER = new TaskPrioritizer<FunctionDescriptor>() {
@NotNull
@@ -825,7 +805,6 @@ public class CallResolver {
}
};
private static TaskPrioritizer<VariableDescriptor> PROPERTY_TASK_PRIORITIZER = new TaskPrioritizer<VariableDescriptor>() {
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
+24 -4
View File
@@ -6,8 +6,10 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.psi.Call;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import java.util.Collection;
@@ -44,6 +46,9 @@ import java.util.List;
* local extension prevail over members (and members prevail over all non-local extensions)
*/
public static boolean isLocal(DeclarationDescriptor containerOfTheCurrentLocality, DeclarationDescriptor candidate) {
if (candidate instanceof ValueParameterDescriptor) {
return true;
}
DeclarationDescriptor parent = candidate.getContainingDeclaration();
if (!(parent instanceof FunctionDescriptor)) {
return false;
@@ -59,11 +64,17 @@ import java.util.List;
return false;
}
public List<ResolutionTask<D>> computePrioritizedTasks(JetScope scope, JetType receiverType, Call call, String name) {
public List<ResolutionTask<D>> computePrioritizedTasks(@NotNull JetScope scope, @Nullable JetType receiverType, @NotNull Call call, @NotNull String name) {
List<ResolutionTask<D>> result = Lists.newArrayList();
doComputeTasks(scope, receiverType, call, name, result);
return result;
}
private void doComputeTasks(JetScope scope, JetType receiverType, Call call, String name, List<ResolutionTask<D>> result) {
List<ReceiverDescriptor> receivers = Lists.newArrayList();
scope.getImplicitReceiversHierarchy(receivers);
if (receiverType != null) {
Collection<D> extensionFunctions = getExtensionsByName(scope, name);
List<D> nonlocals = Lists.newArrayList();
List<D> locals = Lists.newArrayList();
//noinspection unchecked,RedundantTypeArguments
@@ -73,6 +84,12 @@ import java.util.List;
addTask(result, receiverType, call, locals);
addTask(result, null, call, members);
for (ReceiverDescriptor receiver : receivers) {
Collection<D> memberExtensions = getExtensionsByName(receiver.getReceiverType().getMemberScope(), name);
addTask(result, receiverType, call, memberExtensions);
}
addTask(result, receiverType, call, nonlocals);
}
else {
@@ -85,9 +102,12 @@ import java.util.List;
addTask(result, receiverType, call, locals);
for (ReceiverDescriptor receiver : receivers) {
doComputeTasks(scope, receiver.getReceiverType(), call, name, result);
}
addTask(result, receiverType, call, nonlocals);
}
return result;
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedScope.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java
+13 -3
View File
@@ -1,12 +1,14 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* @author abreslav
@@ -69,10 +71,17 @@ public class ChainedScope implements JetScope {
@NotNull
@Override
public JetType getThisType() {
public ReceiverDescriptor getImplicitReceiver() {
throw new UnsupportedOperationException(); // TODO
}
@Override
public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
for (JetScope jetScope : scopeChain) {
jetScope.getImplicitReceiversHierarchy(result);
}
}
@NotNull
@Override
public DeclarationDescriptor getContainingDeclaration() {
@@ -115,6 +124,7 @@ public class ChainedScope implements JetScope {
return null;
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
if (allDescriptors == null) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetScope.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java
+17 -6
View File
@@ -1,11 +1,12 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.Collection;
import java.util.List;
/**
* @author abreslav
@@ -15,7 +16,7 @@ public interface JetScope {
@NotNull
@Override
public DeclarationDescriptor getContainingDeclaration() {
throw new UnsupportedOperationException(); // TODO
throw new UnsupportedOperationException();
}
@Override
@@ -36,9 +37,6 @@ public interface JetScope {
@NotNull
FunctionGroup getFunctionGroup(@NotNull String name);
@NotNull
JetType getThisType();
@NotNull
DeclarationDescriptor getContainingDeclaration();
@@ -55,5 +53,18 @@ public interface JetScope {
@Nullable
DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis();
@NotNull
Collection<DeclarationDescriptor> getAllDescriptors();
/**
* @return EFFECTIVE implicit receiver at this point (may be corresponding to an outer scope)
*/
@NotNull
ReceiverDescriptor getImplicitReceiver();
/**
* Adds receivers to the list in order of locality, so that the closest (the most local) receiver goes first
* @param result
*/
void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetScopeAdapter.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeAdapter.java
+2 -1
View File
@@ -1,6 +1,7 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter;
/**
* @author abreslav
compiler/frontend/src/org/jetbrains/jet/lang/resolve/JetScopeImpl.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java
+10 -4
View File
@@ -1,11 +1,12 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* @author abreslav
@@ -28,8 +29,8 @@ public abstract class JetScopeImpl implements JetScope {
@NotNull
@Override
public JetType getThisType() {
return JetStandardClasses.getNothingType();
public ReceiverDescriptor getImplicitReceiver() {
return ReceiverDescriptor.NO_RECEIVER;
}
@NotNull
@@ -54,8 +55,13 @@ public abstract class JetScopeImpl implements JetScope {
return null;
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
return Collections.emptyList();
}
@Override
public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/LazyScopeAdapter.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/LazyScopeAdapter.java
+2 -1
View File
@@ -1,6 +1,7 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter;
import org.jetbrains.jet.lang.types.LazyValue;
/**
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/RedeclarationHandler.java
+23
View File
@@ -0,0 +1,23 @@
package org.jetbrains.jet.lang.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
/**
* @author abreslav
*/
public interface RedeclarationHandler {
RedeclarationHandler DO_NOTHING = new RedeclarationHandler() {
@Override
public void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
}
};
RedeclarationHandler THROW_EXCEPTION = new RedeclarationHandler() {
@Override
public void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) {
throw new IllegalStateException("Redeclaration: " + first + " and " + second + "(no line info available)");
}
};
void handleRedeclaration(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/SubstitutingScope.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java
+10 -3
View File
@@ -1,14 +1,15 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
@@ -56,7 +57,12 @@ public class SubstitutingScope implements JetScope {
@NotNull
@Override
public JetType getThisType() {
public ReceiverDescriptor getImplicitReceiver() {
throw new UnsupportedOperationException(); // TODO
}
@Override
public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
throw new UnsupportedOperationException(); // TODO
}
@@ -109,6 +115,7 @@ public class SubstitutingScope implements JetScope {
return workerScope.getDeclarationDescriptorForUnqualifiedThis();
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
if (allDescriptors == null) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/WritableScope.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java
+3 -3
View File
@@ -1,9 +1,9 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ImplicitReceiverDescriptor;
/**
* @author abreslav
@@ -30,5 +30,5 @@ public interface WritableScope extends JetScope {
void importScope(@NotNull JetScope imported);
void setThisType(@NotNull JetType thisType);
void setImplicitReceiver(@NotNull ImplicitReceiverDescriptor implicitReceiver);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/WritableScopeImpl.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java
+36 -39
View File
@@ -1,4 +1,4 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
@@ -6,13 +6,12 @@ import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ImplicitReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.*;
import static org.jetbrains.jet.lang.diagnostics.Errors.REDECLARATION;
/**
* @author abreslav
*/
@@ -35,13 +34,12 @@ public class WritableScopeImpl extends WritableScopeWithImports {
@Nullable
private Map<String, List<DeclarationDescriptor>> labelsToDescriptors;
@Nullable
private JetType thisType;
private ImplicitReceiverDescriptor implicitReceiver;
private List<VariableDescriptor> variableDescriptors;
public WritableScopeImpl(@NotNull JetScope scope, @NotNull DeclarationDescriptor owner, @NotNull DiagnosticHolder diagnosticHolder) {
super(scope, diagnosticHolder);
public WritableScopeImpl(@NotNull JetScope scope, @NotNull DeclarationDescriptor owner, @NotNull RedeclarationHandler redeclarationHandler) {
super(scope, redeclarationHandler);
this.ownerDeclarationDescriptor = owner;
}
@@ -70,6 +68,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
super.importClassifierAlias(importedClassifierName, classifierDescriptor);
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
if (!allDescriptorsDone) {
@@ -126,26 +125,16 @@ public class WritableScopeImpl extends WritableScopeWithImports {
return variableClassOrNamespaceDescriptors;
}
@NotNull
private List<VariableDescriptor> getVariableDescriptors() {
if (variableDescriptors == null) {
variableDescriptors = Lists.newArrayList();
}
return variableDescriptors;
}
@Override
public void addVariableDescriptor(@NotNull VariableDescriptor variableDescriptor) {
Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors();
DeclarationDescriptor existingDescriptor = variableClassOrNamespaceDescriptors.get(variableDescriptor.getName());
if (existingDescriptor != null) {
diagnosticHolder.report(REDECLARATION.on(existingDescriptor, variableDescriptor));
redeclarationHandler.handleRedeclaration(existingDescriptor, variableDescriptor);
}
// TODO : Should this always happen?
variableClassOrNamespaceDescriptors.put(variableDescriptor.getName(), variableDescriptor);
allDescriptors.add(variableDescriptor);
getVariableDescriptors().add(variableDescriptor);
}
@Override
@@ -156,12 +145,12 @@ public class WritableScopeImpl extends WritableScopeWithImports {
return (VariableDescriptor) descriptor;
}
if (thisType != null) {
VariableDescriptor variable = getThisType().getMemberScope().getVariable(name);
if (variable != null) {
return variable;
}
}
// if (implicitReceiver != null) {
// VariableDescriptor variable = getImplicitReceiver().getMemberScope().getVariable(name);
// if (variable != null) {
// return variable;
// }
// }
VariableDescriptor variableDescriptor = getWorkerScope().getVariable(name);
if (variableDescriptor != null) {
@@ -203,9 +192,9 @@ public class WritableScopeImpl extends WritableScopeWithImports {
result.addAllFunctions(functionGroup);
}
if (thisType != null) {
result.addAllFunctions(getThisType().getMemberScope().getFunctionGroup(name));
}
// if (implicitReceiver != null) {
// result.addAllFunctions(getImplicitReceiver().getMemberScope().getFunctionGroup(name));
// }
result.addAllFunctions(getWorkerScope().getFunctionGroup(name));
@@ -230,7 +219,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors();
DeclarationDescriptor originalDescriptor = variableClassOrNamespaceDescriptors.get(name);
if (originalDescriptor != null) {
diagnosticHolder.report(REDECLARATION.on(originalDescriptor, classifierDescriptor));
redeclarationHandler.handleRedeclaration(originalDescriptor, classifierDescriptor);
}
variableClassOrNamespaceDescriptors.put(name, classifierDescriptor);
allDescriptors.add(classifierDescriptor);
@@ -250,11 +239,11 @@ public class WritableScopeImpl extends WritableScopeWithImports {
@NotNull
@Override
public JetType getThisType() {
if (thisType == null) {
return super.getThisType();
public ReceiverDescriptor getImplicitReceiver() {
if (implicitReceiver == null) {
return super.getImplicitReceiver();
}
return thisType;
return implicitReceiver;
}
@Override
@@ -262,7 +251,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
Map<String, DeclarationDescriptor> variableClassOrNamespaceDescriptors = getVariableClassOrNamespaceDescriptors();
DeclarationDescriptor oldValue = variableClassOrNamespaceDescriptors.put(namespaceDescriptor.getName(), namespaceDescriptor);
if (oldValue != null) {
diagnosticHolder.report(REDECLARATION.on(oldValue, namespaceDescriptor));
redeclarationHandler.handleRedeclaration(oldValue, namespaceDescriptor);
}
allDescriptors.add(namespaceDescriptor);
}
@@ -286,11 +275,19 @@ public class WritableScopeImpl extends WritableScopeWithImports {
}
@Override
public void setThisType(@NotNull JetType thisType) {
if (this.thisType != null) {
public void setImplicitReceiver(@NotNull ImplicitReceiverDescriptor implicitReceiver) {
if (this.implicitReceiver != null) {
throw new UnsupportedOperationException("Receiver redeclared");
}
this.thisType = thisType;
this.implicitReceiver = implicitReceiver;
}
@Override
public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
if (implicitReceiver != null && implicitReceiver != ReceiverDescriptor.NO_RECEIVER) {
result.add(implicitReceiver);
}
super.getImplicitReceiversHierarchy(result);
}
@SuppressWarnings({"NullableProblems"})
compiler/frontend/src/org/jetbrains/jet/lang/resolve/WritableScopeWithImports.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java
+5 -6
View File
@@ -1,9 +1,8 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
import java.util.ArrayList;
import java.util.List;
@@ -18,11 +17,11 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
@Nullable
private List<JetScope> imports;
private WritableScope currentIndividualImportScope;
protected final DiagnosticHolder diagnosticHolder;
protected final RedeclarationHandler redeclarationHandler;
public WritableScopeWithImports(@NotNull JetScope scope, @NotNull DiagnosticHolder diagnosticHolder) {
public WritableScopeWithImports(@NotNull JetScope scope, @NotNull RedeclarationHandler redeclarationHandler) {
super(scope);
this.diagnosticHolder = diagnosticHolder;
this.redeclarationHandler = redeclarationHandler;
}
public WritableScopeWithImports setDebugName(@NotNull String debugName) {
@@ -97,7 +96,7 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) {
if (currentIndividualImportScope == null) {
WritableScopeImpl writableScope = new WritableScopeImpl(JetScope.EMPTY, getContainingDeclaration(), DiagnosticHolder.DO_NOTHING).setDebugName("Individual import scope");
WritableScopeImpl writableScope = new WritableScopeImpl(EMPTY, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING).setDebugName("Individual import scope");
importScope(writableScope);
currentIndividualImportScope = writableScope;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/WriteThroughScope.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java
+10 -9
View File
@@ -1,11 +1,11 @@
package org.jetbrains.jet.lang.resolve;
package org.jetbrains.jet.lang.resolve.scopes;
import com.google.common.collect.Lists;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ImplicitReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.Collection;
@@ -16,8 +16,8 @@ public class WriteThroughScope extends WritableScopeWithImports {
private final WritableScope writableWorker;
private Collection<DeclarationDescriptor> allDescriptors;
public WriteThroughScope(@NotNull JetScope outerScope, @NotNull WritableScope scope, @NotNull DiagnosticHolder diagnosticHolder) {
super(outerScope, diagnosticHolder);
public WriteThroughScope(@NotNull JetScope outerScope, @NotNull WritableScope scope, @NotNull RedeclarationHandler redeclarationHandler) {
super(outerScope, redeclarationHandler);
this.writableWorker = scope;
}
@@ -41,8 +41,8 @@ public class WriteThroughScope extends WritableScopeWithImports {
@Override
@NotNull
public JetType getThisType() {
return writableWorker.getThisType();
public ReceiverDescriptor getImplicitReceiver() {
return writableWorker.getImplicitReceiver();
}
@Override
@@ -147,10 +147,11 @@ public class WriteThroughScope extends WritableScopeWithImports {
}
@Override
public void setThisType(@NotNull JetType thisType) {
writableWorker.setThisType(thisType);
public void setImplicitReceiver(@NotNull ImplicitReceiverDescriptor implicitReceiver) {
writableWorker.setImplicitReceiver(implicitReceiver);
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
if (allDescriptors == null) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ClassReceiver.java
+13
View File
@@ -0,0 +1,13 @@
package org.jetbrains.jet.lang.resolve.scopes.receivers;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
/**
* @author abreslav
*/
public class ClassReceiver extends ImplicitReceiverDescriptor {
public ClassReceiver(ClassDescriptor classDescriptor) {
super(classDescriptor, classDescriptor.getDefaultType());
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExplicitReceiver.java
+22
View File
@@ -0,0 +1,22 @@
package org.jetbrains.jet.lang.resolve.scopes.receivers;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.types.JetType;
/**
* @author abreslav
*/
public class ExplicitReceiver implements ReceiverDescriptor {
private final JetType type;
public ExplicitReceiver(@NotNull JetType type) {
this.type = type;
}
@NotNull
@Override
public JetType getReceiverType() {
return type;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ExtensionCallableReceiver.java
+13
View File
@@ -0,0 +1,13 @@
package org.jetbrains.jet.lang.resolve.scopes.receivers;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
/**
* @author abreslav
*/
public class ExtensionCallableReceiver extends ImplicitReceiverDescriptor {
public ExtensionCallableReceiver(CallableDescriptor callableDescriptor) {
super(callableDescriptor, callableDescriptor.getReceiverType());
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ImplicitReceiverDescriptor.java
+32
View File
@@ -0,0 +1,32 @@
package org.jetbrains.jet.lang.resolve.scopes.receivers;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.types.JetType;
/**
* Describes a "this" receiver
*
* @author abreslav
*/
public abstract class ImplicitReceiverDescriptor implements ReceiverDescriptor {
private final JetType receiverType;
private final DeclarationDescriptor declarationDescriptor;
protected ImplicitReceiverDescriptor(DeclarationDescriptor declarationDescriptor, JetType receiverType) {
this.receiverType = receiverType;
this.declarationDescriptor = declarationDescriptor;
}
@Override
@NotNull
public JetType getReceiverType() {
return receiverType;
}
@NotNull
public DeclarationDescriptor getDeclarationDescriptor() {
return declarationDescriptor;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ReceiverDescriptor.java
+27
View File
@@ -0,0 +1,27 @@
package org.jetbrains.jet.lang.resolve.scopes.receivers;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.types.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetType;
/**
* @author abreslav
*/
public interface ReceiverDescriptor {
ReceiverDescriptor NO_RECEIVER = new ReceiverDescriptor() {
@NotNull
@Override
public JetType getReceiverType() {
return JetStandardClasses.getNothingType();
}
@Override
public String toString() {
return "NO_RECEIVER";
}
};
@NotNull
JetType getReceiverType();
}
compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
+1 -1
View File
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.List;
compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java
+9 -3
View File
@@ -3,7 +3,8 @@ package org.jetbrains.jet.lang.types;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.*;
@@ -32,8 +33,12 @@ public class ErrorUtils {
@NotNull
@Override
public JetType getThisType() {
return createErrorType("<ERROR TYPE>");
public ReceiverDescriptor getImplicitReceiver() {
return ReceiverDescriptor.NO_RECEIVER;
}
@Override
public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
}
@NotNull
@@ -64,6 +69,7 @@ public class ErrorUtils {
return ERROR_CLASS; // TODO : review
}
@NotNull
@Override
public Collection<DeclarationDescriptor> getAllDescriptors() {
return Collections.emptyList();
compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java
+2 -6
View File
@@ -6,11 +6,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.JetScopeImpl;
import org.jetbrains.jet.lang.resolve.WritableScope;
import org.jetbrains.jet.lang.resolve.WritableScopeImpl;
import org.jetbrains.jet.lang.resolve.scopes.*;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
@@ -198,7 +194,7 @@ public class JetStandardClasses {
/*package*/ static final JetScope STANDARD_CLASSES;
static {
WritableScope writableScope = new WritableScopeImpl(JetScope.EMPTY, STANDARD_CLASSES_NAMESPACE, DiagnosticHolder.DO_NOTHING).setDebugName("JetStandardClasses.STANDARD_CLASSES");
WritableScope writableScope = new WritableScopeImpl(JetScope.EMPTY, STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.DO_NOTHING).setDebugName("JetStandardClasses.STANDARD_CLASSES");
STANDARD_CLASSES = writableScope;
writableScope.addClassifierAlias("Unit", getTuple(0));
compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java
+4 -2
View File
@@ -9,9 +9,11 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionGroup;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.plugin.JetFileType;
import java.io.IOException;
@@ -99,7 +101,7 @@ public class JetStandardLibrary {
JetSemanticServices bootstrappingSemanticServices = JetSemanticServices.createSemanticServices(this);
BindingTraceContext bindingTraceContext = new BindingTraceContext();
WritableScopeImpl writableScope = new WritableScopeImpl(JetStandardClasses.STANDARD_CLASSES, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, DiagnosticHolder.THROW_EXCEPTION).setDebugName("Root bootstrap scope");
WritableScopeImpl writableScope = new WritableScopeImpl(JetStandardClasses.STANDARD_CLASSES, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, RedeclarationHandler.THROW_EXCEPTION).setDebugName("Root bootstrap scope");
// this.libraryScope = bootstrappingTDA.process(JetStandardClasses.STANDARD_CLASSES, file.getRootNamespace().getDeclarations());
// bootstrappingTDA.process(writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace().getDeclarations());
TopDownAnalyzer.processStandardLibraryNamespace(bootstrappingSemanticServices, bindingTraceContext, writableScope, JetStandardClasses.STANDARD_CLASSES_NAMESPACE, file.getRootNamespace());
compiler/frontend/src/org/jetbrains/jet/lang/types/JetType.java
+1 -1
View File
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.List;
compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeImpl.java
+1 -1
View File
@@ -6,7 +6,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotatedImpl;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.Collections;
import java.util.Iterator;
compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java
+44 -27
View File
@@ -23,6 +23,9 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolver;
import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResult;
import org.jetbrains.jet.lang.resolve.constants.*;
import org.jetbrains.jet.lang.resolve.constants.StringValue;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.util.slicedmap.WritableSlice;
@@ -367,7 +370,7 @@ public class JetTypeInferrer {
}
DeclarationDescriptor containingDescriptor = outerScope.getContainingDeclaration();
WritableScope scope = new WritableScopeImpl(outerScope, containingDescriptor, context.trace).setDebugName("getBlockReturnedType");
WritableScope scope = new WritableScopeImpl(outerScope, containingDescriptor, new TraceBasedRedeclarationHandler(context.trace)).setDebugName("getBlockReturnedType");
return getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression, context);
}
@@ -891,7 +894,7 @@ public class JetTypeInferrer {
if (receiverTypeRef != null) {
receiverType = context.typeResolver.resolveType(context.scope, receiverTypeRef);
} else {
receiverType = context.scope.getThisType();
receiverType = context.scope.getImplicitReceiver().getReceiverType();
}
FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
@@ -899,36 +902,46 @@ public class JetTypeInferrer {
List<JetType> parameterTypes = new ArrayList<JetType>();
List<ValueParameterDescriptor> valueParameterDescriptors = Lists.newArrayList();
List<JetParameter> parameters = functionLiteral.getValueParameters();
List<JetParameter> declaredValueParameters = functionLiteral.getValueParameters();
JetType expectedType = context.expectedType;
List<ValueParameterDescriptor> valueParameters = null;
boolean functionTypeExpected = expectedType != NO_EXPECTED_TYPE && JetStandardClasses.isFunctionType(expectedType);
if (functionTypeExpected) {
valueParameters = JetStandardClasses.getValueParameters(functionDescriptor, expectedType);
List<ValueParameterDescriptor> expectedValueParameters = (functionTypeExpected)
? JetStandardClasses.getValueParameters(functionDescriptor, expectedType)
: null;
if (functionTypeExpected && declaredValueParameters.isEmpty() && expectedValueParameters.size() == 1) {
ValueParameterDescriptor valueParameterDescriptor = expectedValueParameters.get(0);
ValueParameterDescriptor it = new ValueParameterDescriptorImpl(
functionDescriptor, 0, Collections.<AnnotationDescriptor>emptyList(), "it", valueParameterDescriptor.getInType(), valueParameterDescriptor.getOutType(), valueParameterDescriptor.hasDefaultValue(), valueParameterDescriptor.isVararg()
);
valueParameterDescriptors.add(it);
parameterTypes.add(it.getOutType());
context.trace.record(AUTO_CREATED_IT, it);
}
else {
for (int i = 0; i < declaredValueParameters.size(); i++) {
JetParameter declaredParameter = declaredValueParameters.get(i);
JetTypeReference typeReference = declaredParameter.getTypeReference();
for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) {
JetParameter parameter = parameters.get(i);
JetTypeReference typeReference = parameter.getTypeReference();
JetType type;
if (typeReference != null) {
type = context.typeResolver.resolveType(context.scope, typeReference);
}
else {
if (valueParameters != null) {
type = valueParameters.get(i).getOutType();
JetType type;
if (typeReference != null) {
type = context.typeResolver.resolveType(context.scope, typeReference);
}
else {
// context.trace.getErrorHandler().genericError(parameter.getNode(), "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) => ...} notation");
context.trace.report(CANNOT_INFER_PARAMETER_TYPE.on(parameter));
type = ErrorUtils.createErrorType("Cannot be inferred");
if (expectedValueParameters != null && i < expectedValueParameters.size()) {
type = expectedValueParameters.get(i).getOutType();
}
else {
// context.trace.getErrorHandler().genericError(declaredParameter.getNode(), "Cannot infer a type for this declaredParameter. To specify it explicitly use the {(p : Type) => ...} notation");
context.trace.report(CANNOT_INFER_PARAMETER_TYPE.on(declaredParameter));
type = ErrorUtils.createErrorType("Cannot be inferred");
}
}
ValueParameterDescriptor valueParameterDescriptor = context.classDescriptorResolver.resolveValueParameterDescriptor(functionDescriptor, declaredParameter, i, type);
parameterTypes.add(valueParameterDescriptor.getOutType());
valueParameterDescriptors.add(valueParameterDescriptor);
}
ValueParameterDescriptor valueParameterDescriptor = context.classDescriptorResolver.resolveValueParameterDescriptor(functionDescriptor, parameter, i, type);
parameterTypes.add(valueParameterDescriptor.getOutType());
valueParameterDescriptors.add(valueParameterDescriptor);
}
JetType effectiveReceiverType;
@@ -974,7 +987,11 @@ public class JetTypeInferrer {
@Override
public JetType visitParenthesizedExpression(JetParenthesizedExpression expression, TypeInferenceContext context) {
return context.services.checkType(getType(expression.getExpression(), context.replaceScope(context.scope)), expression, context);
JetExpression innerExpression = expression.getExpression();
if (innerExpression == null) {
return null;
}
return context.services.checkType(getType(innerExpression, context.replaceScope(context.scope)), expression, context);
}
@Override
@@ -1251,7 +1268,7 @@ public class JetTypeInferrer {
}
}
else {
thisType = context.scope.getThisType();
thisType = context.scope.getImplicitReceiver().getReceiverType();
DeclarationDescriptor declarationDescriptorForUnqualifiedThis = context.scope.getDeclarationDescriptorForUnqualifiedThis();
if (declarationDescriptorForUnqualifiedThis != null) {
@@ -1814,7 +1831,7 @@ public class JetTypeInferrer {
}
protected WritableScopeImpl newWritableScopeImpl(JetScope scope, BindingTrace trace) {
return new WritableScopeImpl(scope, scope.getContainingDeclaration(), trace);
return new WritableScopeImpl(scope, scope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(trace));
}
@Override
compiler/frontend/src/org/jetbrains/jet/lang/types/NamespaceType.java
+1 -1
View File
@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import java.util.List;
compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java
+1 -1
View File
@@ -3,7 +3,7 @@ package org.jetbrains.jet.lang.types;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.resolve.SubstitutingScope;
import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
import java.util.ArrayList;
import java.util.List;
compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
+2 -2
View File
@@ -7,8 +7,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.ChainedScope;
import org.jetbrains.jet.lang.resolve.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.ChainedScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.util.CommonSuppliers;
import java.util.*;