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

Merge branch 'master' of github.com:JetBrains/kotlin

Browse Source
This commit is contained in:
James Strachan
2012-05-04 15:08:12 +01:00
parent 218b7bd973 bc204c1194
commit ad4cbac48d
385 changed files with 5982 additions and 2208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+1 -1
View File
@@ -11,7 +11,7 @@ patches-master
out
dist
ideaSDK
PluginVerifier
dependencies
.idea/dictionaries/yozh.xml
.idea/workspace.xml
tmp
.idea/codeStyleSettings.xml
Generated
+1 -1
View File
@@ -171,7 +171,7 @@
<option name="ALIGN_MULTILINE_THROWS_LIST" value="true" />
<option name="ALIGN_MULTILINE_EXTENDS_LIST" value="true" />
<option name="ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION" value="true" />
<option name="SPACE_AFTER_TYPE_CAST" value="false" />
<option name="SPACE_BEFORE_ARRAY_INITIALIZER_LBRACE" value="true" />
<option name="CALL_PARAMETERS_WRAP" value="1" />
<option name="METHOD_PARAMETERS_WRAP" value="5" />
<option name="EXTENDS_LIST_WRAP" value="1" />
.idea/libraries/js_libs.xml
Generated
-1
View File
@@ -1,7 +1,6 @@
<component name="libraryTable">
<library name="js-libs">
<CLASSES>
<root url="jar://$PROJECT_DIR$/js/js.translator/lib/args4j-2.0.12.jar!/" />
<root url="jar://$PROJECT_DIR$/js/js.translator/lib/json.jar!/" />
<root url="jar://$PROJECT_DIR$/js/js.translator/lib/rhino-1.7R3.jar!/" />
<root url="jar://$PROJECT_DIR$/js/js.translator/lib/dart-r3300.jar!/" />
.idea/runConfigurations/Integration_Tests.xml
Generated
+33
View File
@@ -0,0 +1,33 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Integration Tests" type="JUnit" factoryName="JUnit">
<extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
<pattern>
<option name="PATTERN" value="org.jetbrains.jet.*" />
<option name="ENABLED" value="true" />
</pattern>
</extension>
<module name="compiler-integration-tests" />
<option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
<option name="ALTERNATIVE_JRE_PATH" value="" />
<option name="PACKAGE_NAME" value="org.jetbrains.kotlin" />
<option name="MAIN_CLASS_NAME" value="" />
<option name="METHOD_NAME" value="" />
<option name="TEST_OBJECT" value="package" />
<option name="VM_PARAMETERS" value="-ea -XX:+HeapDumpOnOutOfMemoryError -Xmx350m -XX:MaxPermSize=320m" />
<option name="PARAMETERS" value="" />
<option name="WORKING_DIRECTORY" value="file://$PROJECT_DIR$" />
<option name="ENV_VARIABLES" />
<option name="PASS_PARENT_ENVS" value="true" />
<option name="TEST_SEARCH_SCOPE">
<value defaultName="moduleWithDependencies" />
</option>
<envs />
<patterns />
<RunnerSettings RunnerId="Profile ">
<option name="myExternalizedOptions" value="&#13;&#10;additional-options2=onexit\=snapshot&#13;&#10;" />
</RunnerSettings>
<RunnerSettings RunnerId="Run" />
<ConfigurationWrapper RunnerId="Run" />
<method />
</configuration>
</component>
TeamCityBuild.xml
+2 -2
View File
@@ -10,11 +10,11 @@
<property name="plugin.xml.bk" value="${plugin.xml}.bk"/>
<property name="plugin.xml.versioned" value="${plugin.xml}.versioned" />
<property name="compiler.version.java" value="compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerVersion.java"/>
<property name="compiler.version.java" value="compiler/cli/src/org/jetbrains/jet/cli/common/CompilerVersion.java"/>
<property name="compiler.version.java.bk" value="${compiler.version.java}.bk"/>
<property name="compiler.version.java.versioned" value="${compiler.version.java}.versioned" />
<property name="plugin.verifier" value="${basedir}/PluginVerifier/plugin-verifier-1.0-SNAPSHOT.jar"/>
<property name="plugin.verifier" value="${basedir}/dependencies/plugin-verifier.jar"/>
<property name="plugin.zip" value="${artifact.output.path}/kotlin-plugin-${build.number}.zip" />
<macrodef name="echoprop">
bin/kotlin
+1
View File
@@ -23,6 +23,7 @@ classpath="$classpath:$root/out/production/stdlib"
classpath="$classpath:$root/lib/*:$ideaRoot/lib/*:$ideaRoot/lib/rt/*"
exec java $JAVA_OPTS \
-ea \
-classpath "$classpath" \
org.jetbrains.jet.cli.jvm.K2JVMCompiler \
"$@"
build-tools/core/src/org/jetbrains/jet/buildtools/core/BytecodeCompiler.java
+5 -4
View File
@@ -42,17 +42,18 @@ public class BytecodeCompiler {
/**
* Creates new instance of {@link org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentConfiguration} instance using the arguments specified.
* Creates new instance of {@link org.jetbrains.jet.cli.jvm.compiler.K2JVMCompileEnvironmentConfiguration} instance using the arguments specified.
*
* @param stdlib path to "kotlin-runtime.jar", only used if not null and not empty
* @param classpath compilation classpath, only used if not null and not empty
*
* @return compile environment instance
*/
private CompileEnvironmentConfiguration env( String stdlib, String[] classpath ) {
private K2JVMCompileEnvironmentConfiguration env( String stdlib, String[] classpath ) {
CompilerDependencies dependencies = CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR);
JetCoreEnvironment environment = new JetCoreEnvironment(CompileEnvironmentUtil.createMockDisposable(), dependencies);
CompileEnvironmentConfiguration env = new CompileEnvironmentConfiguration(environment, dependencies, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);
K2JVMCompileEnvironmentConfiguration
env = new K2JVMCompileEnvironmentConfiguration(environment, MessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);
if (( stdlib != null ) && ( stdlib.trim().length() > 0 )) {
File file = new File(stdlib);
@@ -140,7 +141,7 @@ public class BytecodeCompiler {
*/
public void moduleToJar ( @NotNull String module, @NotNull String jar, boolean includeRuntime, @Nullable String stdlib, @Nullable String[] classpath ) {
try {
CompileEnvironmentConfiguration env = env(stdlib, classpath);
K2JVMCompileEnvironmentConfiguration env = env(stdlib, classpath);
List<Module> modules = CompileEnvironmentUtil.loadModuleScript(module, env.getMessageCollector());
File directory = new File(module).getParentFile();
boolean success = KotlinToJVMBytecodeCompiler.compileModules(env, modules, directory, jar, null, includeRuntime);
build.xml
+88 -6
View File
@@ -19,6 +19,7 @@
<pathelement path="${idea.sdk}/lib/resources_en.jar"/>
<fileset dir="${basedir}/lib" includes="**/*.jar"/>
<fileset dir="${basedir}/js/js.translator/lib" includes="*.jar"/>
<pathelement path="${output}/classes/runtime"/>
</path>
@@ -36,6 +37,9 @@
<include name="util/src"/>
<include name="jet.as.java.psi/src"/>
</dirset>
<dirset dir="${basedir}/js/js.translator">
<include name="src"/>
</dirset>
</path>
<target name="init" depends="clean">
@@ -166,17 +170,40 @@
</target>
<target name="jarjar">
<taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpath="${basedir}/build/jarjar-1.2.jar"/>
<taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpath="${basedir}/dependencies/jarjar.jar"/>
<taskdef resource="proguard/ant/task.properties" classpath="${basedir}/dependencies/proguard.jar"/>
<jarjar jarfile="${output}/kotlin-compiler-tmp.jar">
<!-- JarJar Kotlin compiler & dependencies -->
<delete file="${output}/kotlin-compiler-jarjar.jar" failonerror="false"/>
<jarjar jarfile="${output}/kotlin-compiler-jarjar.jar">
<fileset dir="${output}/classes/compiler"/>
<fileset dir="${output}/classes/runtime"/>
<fileset dir="${basedir}/compiler/frontend/src" includes="jet/**"/>
<zipgroupfileset dir="${basedir}/lib" includes="*.jar"/>
<zipgroupfileset dir="${basedir}/ideaSDK/core" includes="*.jar"/>
<zipgroupfileset dir="${basedir}/js/js.translator/lib" includes="*.jar"/>
<zap pattern="com.thoughtworks.xstream.converters.extended.ISO8601*"/>
<zap pattern="com.thoughtworks.xstream.converters.reflection.CGLIBEnhancedConverter*"/>
<zap pattern="com.thoughtworks.xstream.io.xml.Dom4J*"/>
<zap pattern="com.thoughtworks.xstream.io.xml.Xom*"/>
<zap pattern="com.thoughtworks.xstream.mapper.CGLIBMapper*"/>
<zap pattern="org.apache.log4j.jmx.Agent"/>
<zap pattern="org.apache.log4j.net.JMS*"/>
<zap pattern="org.apache.log4j.net.SMTP*"/>
<zap pattern="org.apache.log4j.or.jms.MessageRenderer"/>
<zap pattern="org.jdom.xpath.Jaxen*"/>
<zap pattern="org.mozilla.javascript.xml.impl.xmlbeans.**" />
<rule pattern="com.intellij.**" result="kotlinc.internal.com.intellij.@1"/>
<rule pattern="com.sun.jna.**" result="kotlinc.internal.com.sun.jna.@1"/>
<rule pattern="org.apache.log4j.**" result="kotlinc.internal.org.apache.log4j.@1"/>
<rule pattern="org.jdom.**" result="kotlinc.internal.org.jdom.@1"/>
<rule pattern="JDOMAbout**" result="kotlinc.internal.org.jdom.JDOMAbout@1"/>
<rule pattern="org.intellij.lang.annotations.**" result="kotlinc.internal.org.intellij.lang.annotations.@1"/>
<rule pattern="org.jetbrains.annotations.**" result="kotlinc.internal.org.jetbrains.annotations.@1"/>
<rule pattern="com.google.**" result="kotlinc.internal.com.google.@1"/>
@@ -189,11 +216,13 @@
<delete failonerror="false" dir="${output}/kotlin-compiler.exploded"/>
<mkdir dir="${output}/kotlin-compiler.exploded"/>
<unzip src="${output}/kotlin-compiler-jarjar.jar" dest="${output}/kotlin-compiler.exploded"/>
<unzip src="${output}/kotlin-compiler-tmp.jar" dest="${output}/kotlin-compiler.exploded"/>
<delete file="${output}/kotlin-compiler-tmp.jar"/>
<delete file="${output}/kotlin-compiler-jarjar.jar"/>
<jar jarfile="${output}/kotlin-compiler-standalone.jar">
<!-- Clean JarJar result -->
<delete file="${output}/kotlin-compiler-clean.jar" failonerror="false"/>
<jar jarfile="${output}/kotlin-compiler-clean.jar">
<fileset dir="${output}/kotlin-compiler.exploded">
<include name="**/*.class"/>
<include name="**/*.jet"/>
@@ -213,8 +242,61 @@
<attribute name="Main-Class" value="org.jetbrains.jet.cli.jvm.K2JVMCompiler"/>
</manifest>
</jar>
<delete dir="${output}/kotlin-compiler.exploded" />
<available property="rtjar" value="${java.home}/lib/rt.jar" file="${java.home}/lib/rt.jar" />
<available property="rtjar" value="${java.home}/../Classes/classes.jar" file="${java.home}/../Classes/classes.jar" />
<delete file="${output}/kotlin-compiler.jar" failonerror="false"/>
<proguard><![CDATA[
-injars '${output}/kotlin-compiler-clean.jar'
-outjars '${output}/kotlin-compiler.jar'
-libraryjars '${rtjar}'
-target 1.6
-dontoptimize
-dontobfuscate
# Keep application classes, along with their 'main' methods.
-keepclasseswithmembers public class * {
public static void main(java.lang.String[]);
}
-keepclasseswithmembers class * {
# Various dynamically called methods
void start();
void stop();
void dispose();
** getFileSystem();
** isVarArgs();
** getApplication();
** finalizeReferent();
** newBuilder();
** startFinalizer(java.lang.Class,java.lang.Object);
** executeOnPooledThread(java.lang.Runnable);
** getUserData(java.lang.String);
int getBooleanAttributes(java.io.File);
<init>(kotlinc.internal.com.intellij.lang.ASTNode);
}
# Keep the special static methods that are required in enumeration classes.
-keepclassmembers enum * {
public static **[] values();
public static ** valueOf(java.lang.String);
}
-keepclassmembers class * {
** toString();
** hashCode();
** project();
** TYPE;
** ourInstance;
}
]]></proguard>
<delete file="${output}/kotlin-compiler-clean.jar" />
</target>
<target name="clean">
build/jarjar-1.2.jar
BIN
View File
Binary file not shown.
compiler/backend/src/org/jetbrains/jet/codegen/CallableMethod.java
+1 -1
View File
@@ -79,7 +79,7 @@ public class CallableMethod implements Callable {
}
public void setNeedsReceiver(@Nullable CallableDescriptor receiverClass) {
this.receiverFunction = receiverClass;
this.receiverFunction = receiverClass.getOriginal();
}
public JetType getThisType() {
compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+79 -22
View File
@@ -154,7 +154,8 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
throw e;
}
catch (Throwable error) {
throw new CompilationException(error.getMessage(), error, selector);
String message = error.getMessage();
throw new CompilationException(message != null ? message : "null", error, selector);
}
}
@@ -888,7 +889,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
return answer;
}
private void markLineNumber(JetElement statement) {
private void markLineNumber(@NotNull JetElement statement) {
final Document document = statement.getContainingFile().getViewProvider().getDocument();
if (document != null) {
int lineNumber = document.getLineNumber(statement.getTextRange().getStartOffset()); // 0-based
@@ -963,13 +964,17 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expression);
}
else {
if(resolvedCall instanceof VariableAsFunctionResolvedCall) {
VariableAsFunctionResolvedCall call = (VariableAsFunctionResolvedCall) resolvedCall;
resolvedCall = call.getVariableCall();
}
receiver = StackValue.receiver(resolvedCall, receiver, this, null, state);
descriptor = resolvedCall.getResultingDescriptor();
}
if (descriptor instanceof VariableAsFunctionDescriptor) {
descriptor = ((VariableAsFunctionDescriptor) descriptor).getVariableDescriptor();
}
//if (descriptor instanceof VariableAsFunctionDescriptor) {
// descriptor = ((VariableAsFunctionDescriptor) descriptor).getVariableDescriptor();
//}
final IntrinsicMethod intrinsic = state.getInjector().getIntrinsics().getIntrinsic(descriptor);
if (intrinsic != null) {
@@ -1254,14 +1259,24 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
}
else if (funDescriptor instanceof FunctionDescriptor) {
final FunctionDescriptor fd = (FunctionDescriptor) funDescriptor;
return invokeFunction(expression, fd, receiver);
if(resolvedCall instanceof VariableAsFunctionResolvedCall) {
VariableAsFunctionResolvedCall call = (VariableAsFunctionResolvedCall) resolvedCall;
ResolvedCallWithTrace<FunctionDescriptor> functionCall = call.getFunctionCall();
return invokeFunction(expression, functionCall.getResultingDescriptor(), receiver, functionCall);
}
else {
return invokeFunction(expression, fd, receiver, resolvedCall);
}
}
else {
throw new UnsupportedOperationException("unknown type of callee descriptor: " + funDescriptor);
}
}
private StackValue invokeFunction(JetCallExpression expression, DeclarationDescriptor fd, StackValue receiver) {
private StackValue invokeFunction(JetCallExpression expression,
DeclarationDescriptor fd,
StackValue receiver,
ResolvedCall<? extends CallableDescriptor> resolvedCall) {
boolean superCall = false;
if (expression.getParent() instanceof JetQualifiedExpression) {
final JetExpression receiverExpression = ((JetQualifiedExpression) expression.getParent()).getReceiverExpression();
@@ -1294,8 +1309,6 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
return returnValueAsStackValue((FunctionDescriptor) fd, callReturnType);
}
else {
ResolvedCall<? extends CallableDescriptor> resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression());
assert resolvedCall != null;
receiver = StackValue.receiver(resolvedCall, receiver, this, null, state);
IntrinsicMethod intrinsic = (IntrinsicMethod) callable;
@@ -1323,11 +1336,11 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
}
CallableMethod callableMethod;
if (fd instanceof VariableAsFunctionDescriptor) {
assert !superCall;
callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd);
}
else if (fd instanceof ExpressionAsFunctionDescriptor || (fd instanceof SimpleFunctionDescriptor && fd.getContainingDeclaration() instanceof FunctionDescriptor)) {
//if (fd instanceof VariableAsFunctionDescriptor) {
// assert !superCall;
// callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd);
//}
if (fd instanceof ExpressionAsFunctionDescriptor || (fd instanceof SimpleFunctionDescriptor && fd.getContainingDeclaration() instanceof FunctionDescriptor)) {
SimpleFunctionDescriptor invoke = CodegenUtil.createInvoke((FunctionDescriptor) fd);
callableMethod = ClosureCodegen.asCallableMethod(invoke);
}
@@ -1350,6 +1363,10 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
ResolvedCall<? extends CallableDescriptor> resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression());
assert resolvedCall != null;
if(resolvedCall instanceof VariableAsFunctionResolvedCall) {
resolvedCall = ((VariableAsFunctionResolvedCall)resolvedCall).getFunctionCall();
}
if(!(resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor)) { // otherwise already
receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod, state);
receiver.put(receiver.type, v);
@@ -1396,7 +1413,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
else if(descriptor instanceof ExpressionReceiver) {
ExpressionReceiver expressionReceiver = (ExpressionReceiver) descriptor;
JetExpression expr = expressionReceiver.getExpression();
Type exprType = expressionType(expr);
Type exprType = asmType(expressionReceiver.getType());
gen(expr, exprType);
if(type != null)
StackValue.onStack(exprType).put(type, v);
@@ -1529,15 +1546,55 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> {
Type type = asmType(outType);
assert type.getSort() == Type.ARRAY;
Type elementType = correctElementType(type);
int size = valueArgument.getArguments().size();
List<ValueArgument> arguments = valueArgument.getArguments();
int size = arguments.size();
v.iconst(valueArgument.getArguments().size());
v.newarray(elementType);
boolean hasSpread = false;
for(int i = 0; i != size; ++i) {
v.dup();
v.iconst(i);
gen(valueArgument.getArguments().get(i).getArgumentExpression(), elementType);
StackValue.arrayElement(elementType, false).store(v);
if(arguments.get(i).getSpreadElement() != null) {
hasSpread = true;
break;
}
}
if(hasSpread) {
if(size == 1) {
gen(arguments.get(0).getArgumentExpression(), type);
}
else {
String owner = "jet/runtime/Intrinsics$SpreadBuilder";
v.anew(Type.getObjectType(owner));
v.dup();
v.invokespecial(owner, "<init>", "()V");
for(int i = 0; i != size; ++i) {
v.dup();
ValueArgument argument = arguments.get(i);
if(argument.getSpreadElement() != null) {
gen(argument.getArgumentExpression(),JetTypeMapper.TYPE_OBJECT);
v.invokevirtual(owner, "addSpread", "(Ljava/lang/Object;)V");
}
else {
gen(argument.getArgumentExpression(), elementType);
v.invokevirtual(owner, "add", "(Ljava/lang/Object;)Z");
v.pop();
}
}
v.dup();
v.invokevirtual(owner, "size", "()I");
v.newarray(elementType);
v.invokevirtual(owner, "toArray", "([Ljava/lang/Object;)[Ljava/lang/Object;");
v.checkcast(type);
}
}
else {
v.iconst(arguments.size());
v.newarray(elementType);
for(int i = 0; i != size; ++i) {
v.dup();
v.iconst(i);
gen(arguments.get(i).getArgumentExpression(), elementType);
StackValue.arrayElement(elementType, false).store(v);
}
}
}
compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java
+15 -15
View File
@@ -159,7 +159,7 @@ public class FunctionCodegen {
JetValueParameterAnnotationWriter av = JetValueParameterAnnotationWriter.visitParameterAnnotation(mv, i + start);
ValueParameterDescriptor parameterDescriptor = paramDescrs.get(i);
av.writeName(parameterDescriptor.getName());
av.writeHasDefaultValue(parameterDescriptor.hasDefaultValue());
av.writeHasDefaultValue(parameterDescriptor.declaresDefaultValue());
av.writeNullable(parameterDescriptor.getType().isNullable());
if (jvmSignature.getKotlinParameterTypes() != null && jvmSignature.getKotlinParameterTypes().get(i) != null) {
av.writeType(jvmSignature.getKotlinParameterTypes().get(i + start).getKotlinSignature());
@@ -312,7 +312,7 @@ public class FunctionCodegen {
boolean needed = false;
if(functionDescriptor != null) {
for (ValueParameterDescriptor parameterDescriptor : functionDescriptor.getValueParameters()) {
if(parameterDescriptor.hasDefaultValue()) {
if(parameterDescriptor.declaresDefaultValue()) {
needed = true;
break;
}
@@ -398,7 +398,7 @@ public class FunctionCodegen {
Type t = argumentTypes[extra + index];
Label endArg = null;
if (parameterDescriptor.hasDefaultValue()) {
if (parameterDescriptor.declaresDefaultValue()) {
iv.load(maskIndex, Type.INT_TYPE);
iv.iconst(1 << index);
iv.and(Type.INT_TYPE);
@@ -418,7 +418,7 @@ public class FunctionCodegen {
iv.load(var, t);
var += t.getSize();
if (parameterDescriptor.hasDefaultValue()) {
if (parameterDescriptor.declaresDefaultValue()) {
iv.mark(endArg);
}
}
@@ -446,22 +446,22 @@ public class FunctionCodegen {
}
}
private static boolean differentMethods(Method method, Method overriden) {
if(!method.getReturnType().equals(overriden.getReturnType()))
private static boolean differentMethods(Method method, Method overridden) {
if(!method.getReturnType().equals(overridden.getReturnType()))
return true;
Type[] methodArgumentTypes = method.getArgumentTypes();
Type[] overridenArgumentTypes = overriden.getArgumentTypes();
if(methodArgumentTypes.length != overridenArgumentTypes.length)
Type[] overriddenArgumentTypes = overridden.getArgumentTypes();
if(methodArgumentTypes.length != overriddenArgumentTypes.length)
return true;
for(int i = 0; i != methodArgumentTypes.length; ++i)
if(!methodArgumentTypes[i].equals(overridenArgumentTypes[i]))
if(!methodArgumentTypes[i].equals(overriddenArgumentTypes[i]))
return true;
return false;
}
private static void checkOverride(CodegenContext owner, GenerationState state, ClassBuilder v, Method jvmSignature, FunctionDescriptor functionDescriptor, FunctionDescriptor overriddenFunction) {
Method method = state.getInjector().getJetTypeMapper().mapSignature(functionDescriptor.getName(), functionDescriptor).getAsmMethod();
Method overriden = state.getInjector().getJetTypeMapper().mapSignature(overriddenFunction.getName(), overriddenFunction.getOriginal()).getAsmMethod();
Method overridden = state.getInjector().getJetTypeMapper().mapSignature(overriddenFunction.getName(), overriddenFunction.getOriginal()).getAsmMethod();
if(overriddenFunction.getModality() == Modality.ABSTRACT) {
Set<? extends FunctionDescriptor> overriddenFunctions = overriddenFunction.getOverriddenDescriptors();
@@ -470,17 +470,17 @@ public class FunctionCodegen {
}
}
if(differentMethods(method, overriden)) {
if(differentMethods(method, overridden)) {
int flags = ACC_PUBLIC | ACC_BRIDGE; // TODO.
final MethodVisitor mv = v.newMethod(null, flags, jvmSignature.getName(), overriden.getDescriptor(), null, null);
final MethodVisitor mv = v.newMethod(null, flags, jvmSignature.getName(), overridden.getDescriptor(), null, null);
if (state.getClassBuilderMode() == ClassBuilderMode.STUBS) {
StubCodegen.generateStubCode(mv);
}
else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
mv.visitCode();
Type[] argTypes = overriden.getArgumentTypes();
Type[] argTypes = overridden.getArgumentTypes();
InstructionAdapter iv = new InstructionAdapter(mv);
iv.load(0, JetTypeMapper.TYPE_OBJECT);
for (int i = 0, reg = 1; i < argTypes.length; i++) {
@@ -495,11 +495,11 @@ public class FunctionCodegen {
}
iv.invokevirtual(state.getInjector().getJetTypeMapper().mapType(((ClassDescriptor) owner.getContextDescriptor()).getDefaultType(), MapTypeMode.VALUE).getInternalName(), jvmSignature.getName(), jvmSignature.getDescriptor());
if(JetTypeMapper.isPrimitive(jvmSignature.getReturnType()) && !JetTypeMapper.isPrimitive(overriden.getReturnType()))
if(JetTypeMapper.isPrimitive(jvmSignature.getReturnType()) && !JetTypeMapper.isPrimitive(overridden.getReturnType()))
StackValue.valueOf(iv, jvmSignature.getReturnType());
if(jvmSignature.getReturnType() == Type.VOID_TYPE)
iv.aconst(null);
iv.areturn(overriden.getReturnType());
iv.areturn(overridden.getReturnType());
endVisit(mv, "bridge method", BindingContextUtils.callableDescriptorToDeclaration(state.getBindingContext(), functionDescriptor));
}
}
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+8 -8
View File
@@ -551,7 +551,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
for (ValueParameterDescriptor valueParameter : constructorDescriptor.getValueParameters()) {
JetValueParameterAnnotationWriter jetValueParameterAnnotation = JetValueParameterAnnotationWriter.visitParameterAnnotation(mv, i);
jetValueParameterAnnotation.writeName(valueParameter.getName());
jetValueParameterAnnotation.writeHasDefaultValue(valueParameter.hasDefaultValue());
jetValueParameterAnnotation.writeHasDefaultValue(valueParameter.declaresDefaultValue());
jetValueParameterAnnotation.writeType(constructorMethod.getKotlinParameterType(i));
jetValueParameterAnnotation.visitEnd();
++i;
@@ -1024,18 +1024,18 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
continue;
}
Collection<CallableMemberDescriptor> overridenDeclarations = OverridingUtil.getOverridenDeclarations(callableMemberDescriptor);
for (CallableMemberDescriptor overridenDeclaration : overridenDeclarations) {
if (overridenDeclaration.getModality() != Modality.ABSTRACT) {
if (!CodegenUtil.isInterface(overridenDeclaration.getContainingDeclaration())) {
Collection<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(callableMemberDescriptor);
for (CallableMemberDescriptor overriddenDeclaration : overriddenDeclarations) {
if (overriddenDeclaration.getModality() != Modality.ABSTRACT) {
if (!CodegenUtil.isInterface(overriddenDeclaration.getContainingDeclaration())) {
continue root;
}
}
}
for (CallableMemberDescriptor overridenDeclaration : overridenDeclarations) {
if (overridenDeclaration.getModality() != Modality.ABSTRACT) {
r.add(Pair.create(callableMemberDescriptor, overridenDeclaration));
for (CallableMemberDescriptor overriddenDeclaration : overriddenDeclarations) {
if (overriddenDeclaration.getModality() != Modality.ABSTRACT) {
r.add(Pair.create(callableMemberDescriptor, overriddenDeclaration));
}
}
}
compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java
+5 -3
View File
@@ -54,6 +54,7 @@ public class JetTypeMapper {
public static final Type TYPE_NOTHING = Type.getObjectType("jet/Nothing");
public static final Type JL_NUMBER_TYPE = Type.getObjectType("java/lang/Number");
public static final Type JL_STRING_BUILDER = Type.getObjectType("java/lang/StringBuilder");
public static final Type JL_ARRAY_LIST = Type.getObjectType("java/util/ArrayList");
public static final Type JL_STRING_TYPE = Type.getObjectType("java/lang/String");
public static final Type JL_CHAR_SEQUENCE_TYPE = Type.getObjectType("java/lang/CharSequence");
private static final Type JL_COMPARABLE_TYPE = Type.getObjectType("java/lang/Comparable");
@@ -941,9 +942,10 @@ public class JetTypeMapper {
return StackValue.sharedTypeForType(mapType(((FunctionDescriptor) descriptor).getReceiverParameter().getType(), MapTypeMode.VALUE));
}
else if (descriptor instanceof VariableDescriptor) {
Boolean aBoolean = bindingContext.get(BindingContext.MUST_BE_WRAPPED_IN_A_REF, (VariableDescriptor) descriptor);
if (aBoolean != null && aBoolean) {
JetType outType = ((VariableDescriptor) descriptor).getType();
VariableDescriptor variableDescriptor = (VariableDescriptor) descriptor;
Boolean aBoolean = bindingContext.get(BindingContext.CAPTURED_IN_CLOSURE, variableDescriptor);
if (aBoolean != null && aBoolean && variableDescriptor.isVar()) {
JetType outType = variableDescriptor.getType();
return StackValue.sharedTypeForType(mapType(outType, MapTypeMode.VALUE));
}
else {
compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
+3 -1
View File
@@ -34,12 +34,14 @@ import java.util.List;
public class Concat implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) {
codegen.generateStringBuilderConstructor();
if (receiver == null || receiver == StackValue.none()) { // LHS + RHS
codegen.generateStringBuilderConstructor();
codegen.invokeAppend(arguments.get(0)); // StringBuilder(LHS)
codegen.invokeAppend(arguments.get(1));
}
else { // LHS.plus(RHS)
receiver.put(JetTypeMapper.TYPE_OBJECT, v);
codegen.generateStringBuilderConstructor();
v.swap(); // StringBuilder LHS
codegen.invokeAppendMethod(expectedType); // StringBuilder(LHS)
codegen.invokeAppend(arguments.get(0));
compiler/cli/cli.iml
+1
View File
@@ -14,6 +14,7 @@
<orderEntry type="module" module-name="jet.as.java.psi" />
<orderEntry type="library" name="intellij-core" level="project" />
<orderEntry type="library" name="asm" level="project" />
<orderEntry type="module" module-name="js.translator" />
</component>
</module>
compiler/cli/src/org/jetbrains/jet/cli/common/CLICompiler.java
+154
View File
@@ -0,0 +1,154 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.cli.common;
import com.sampullara.cli.Args;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation;
import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
import org.jetbrains.jet.cli.common.messages.MessageRenderer;
import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentException;
import java.io.PrintStream;
import java.util.List;
import static org.jetbrains.jet.cli.common.ExitCode.INTERNAL_ERROR;
import static org.jetbrains.jet.cli.common.ExitCode.OK;
/**
* @author Pavel Talanov
*/
public abstract class CLICompiler<A extends CompilerArguments, C extends CompileEnvironmentConfiguration> {
@NotNull
public ExitCode exec(@NotNull PrintStream errStream, @NotNull String... args) {
A arguments = createArguments();
if (!parseArguments(errStream, arguments, args)) {
return INTERNAL_ERROR;
}
return exec(errStream, arguments);
}
/**
* Returns true if the arguments can be parsed correctly
*/
protected boolean parseArguments(@NotNull PrintStream errStream, @NotNull A arguments, @NotNull String[] args) {
try {
Args.parse(arguments, args);
return true;
}
catch (IllegalArgumentException e) {
usage(errStream);
}
catch (Throwable t) {
// Always use tags
errStream.println(MessageRenderer.TAGS.renderException(t));
}
return false;
}
/**
* Allow derived classes to add additional command line arguments
*/
protected void usage(@NotNull PrintStream target) {
// We should say something like
// Args.usage(target, K2JVMCompilerArguments.class);
// but currently cli-parser we are using does not support that
// a corresponding patch has been sent to the authors
// For now, we are using this:
PrintStream oldErr = System.err;
System.setErr(target);
try {
// TODO: use proper argv0
Args.usage(createArguments());
}
finally {
System.setErr(oldErr);
}
}
/**
* Strategy method to configure the environment, allowing compiler
* based tools to customise their own plugins
*/
//TODO: add parameter annotations when KT-1863 is resolved
protected void configureEnvironment(@NotNull C configuration, @NotNull A arguments) {
List<CompilerPlugin> plugins = arguments.getCompilerPlugins();
configuration.getCompilerPlugins().addAll(plugins);
}
@NotNull
protected abstract A createArguments();
/**
* Executes the compiler on the parsed arguments
*/
@NotNull
public ExitCode exec(final PrintStream errStream, A arguments) {
if (arguments.isHelp()) {
usage(errStream);
return OK;
}
System.setProperty("java.awt.headless", "true");
final MessageRenderer messageRenderer = getMessageRenderer(arguments);
errStream.print(messageRenderer.renderPreamble());
printVersionIfNeeded(errStream, arguments, messageRenderer);
try {
return doExecute(errStream, arguments, messageRenderer);
}
finally {
errStream.print(messageRenderer.renderConclusion());
}
}
//TODO: can't declare parameters as not null due to KT-1863
@NotNull
protected abstract ExitCode doExecute(PrintStream stream, A arguments, MessageRenderer renderer);
@NotNull
private MessageRenderer getMessageRenderer(@NotNull A arguments) {
return arguments.isTags() ? MessageRenderer.TAGS : MessageRenderer.PLAIN;
}
protected void printVersionIfNeeded(@NotNull PrintStream errStream,
@NotNull A arguments,
@NotNull MessageRenderer messageRenderer) {
if (arguments.isVersion()) {
String versionMessage = messageRenderer.render(CompilerMessageSeverity.INFO,
"Kotlin Compiler version " + CompilerVersion.VERSION,
CompilerMessageLocation.NO_LOCATION);
errStream.println(versionMessage);
}
}
/**
* Useful main for derived command line tools
*/
public static void doMain(@NotNull CLICompiler compiler, @NotNull String[] args) {
try {
ExitCode rc = compiler.exec(System.out, args);
if (rc != OK) {
System.err.println("exec() finished with " + rc + " return code");
System.exit(rc.getCode());
}
}
catch (CompileEnvironmentException e) {
System.err.println(e.getMessage());
System.exit(INTERNAL_ERROR.getCode());
}
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentConfiguration.java → compiler/cli/src/org/jetbrains/jet/cli/common/CompileEnvironmentConfiguration.java
+10 -22
View File
@@ -14,45 +14,32 @@
* limitations under the License.
*/
package org.jetbrains.jet.cli.jvm.compiler;
package org.jetbrains.jet.cli.common;
import com.google.common.collect.Lists;
import com.intellij.openapi.util.Disposer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.CompilerPlugin;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
import org.jetbrains.jet.lang.resolve.java.CompilerDependencies;
import java.util.List;
/**
* @author abreslav
* @author Pavel Talanov
*/
public class CompileEnvironmentConfiguration {
private final JetCoreEnvironment environment;
private final CompilerDependencies compilerDependencies;
private final MessageCollector messageCollector;
public abstract class CompileEnvironmentConfiguration {
private List<CompilerPlugin> compilerPlugins = Lists.newArrayList();
@NotNull
private final MessageCollector messageCollector;
@NotNull
private final List<CompilerPlugin> compilerPlugins = Lists.newArrayList();
/**
* NOTE: It's very important to call dispose for every object of this class or there will be memory leaks.
*
* @see Disposer
*/
public CompileEnvironmentConfiguration(@NotNull JetCoreEnvironment environment,
@NotNull CompilerDependencies compilerDependencies, @NotNull MessageCollector messageCollector) {
public CompileEnvironmentConfiguration(@NotNull MessageCollector messageCollector) {
this.messageCollector = messageCollector;
this.compilerDependencies = compilerDependencies;
this.environment = environment;
}
public JetCoreEnvironment getEnvironment() {
return environment;
}
@NotNull
public CompilerDependencies getCompilerDependencies() {
return compilerDependencies;
}
@NotNull
@@ -60,6 +47,7 @@ public class CompileEnvironmentConfiguration {
return messageCollector;
}
@NotNull
public List<CompilerPlugin> getCompilerPlugins() {
return compilerPlugins;
}
compiler/cli/src/org/jetbrains/jet/cli/common/CompilerArguments.java
+47
View File
@@ -0,0 +1,47 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.cli.common;
import com.google.common.collect.Lists;
import com.sampullara.cli.Argument;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* @author Pavel Talanov
*/
public abstract class CompilerArguments {
@NotNull
private List<CompilerPlugin> compilerPlugins = Lists.newArrayList();
@NotNull
public List<CompilerPlugin> getCompilerPlugins() {
return compilerPlugins;
}
/**
* Sets the compiler plugins to be used when working with the {@link org.jetbrains.jet.cli.CLICompiler}
*/
public void setCompilerPlugins(@NotNull List<CompilerPlugin> compilerPlugins) {
this.compilerPlugins = compilerPlugins;
}
public abstract boolean isHelp();
public abstract boolean isTags();
public abstract boolean isVersion();
}
compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPlugin.java
+3 -1
View File
@@ -16,10 +16,12 @@
package org.jetbrains.jet.cli.common;
import org.jetbrains.annotations.NotNull;
/**
* A simple interface for compiler plugins to run after the compiler has finished such as for things like
* generating documentation or code generation etc
*/
public interface CompilerPlugin {
void processFiles(CompilerPluginContext context);
void processFiles(@NotNull CompilerPluginContext context);
}
compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java
+8
View File
@@ -17,6 +17,7 @@
package org.jetbrains.jet.cli.common;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -27,8 +28,12 @@ import java.util.List;
* the {@link Project}, the {@link BindingContext} and the underlying {@link JetFile} files.
*/
public class CompilerPluginContext {
@NotNull
private final Project project;
//TODO: should we in fact store AnalyzeExhaust here?
@NotNull
private final BindingContext context;
@NotNull
private final List<JetFile> files;
public CompilerPluginContext(Project project, BindingContext context, List<JetFile> files) {
@@ -37,14 +42,17 @@ public class CompilerPluginContext {
this.files = files;
}
@NotNull
public BindingContext getContext() {
return context;
}
@NotNull
public List<JetFile> getFiles() {
return files;
}
@NotNull
public Project getProject() {
return project;
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerVersion.java → compiler/cli/src/org/jetbrains/jet/cli/common/CompilerVersion.java
+2 -2
View File
@@ -14,12 +14,12 @@
* limitations under the License.
*/
package org.jetbrains.jet.cli.jvm;
package org.jetbrains.jet.cli.common;
/**
* @author abreslav
*/
public class K2JVMCompilerVersion {
public class CompilerVersion {
// The value of this constant is generated by the build script
// DON'T MODIFY IT
public static final String VERSION = "@snapshot@";
compiler/cli/src/org/jetbrains/jet/cli/common/messages/MessageRenderer.java
+1 -1
View File
@@ -42,7 +42,7 @@ public interface MessageRenderer {
out.append(" line=\"").append(location.getLine()).append("\"");
out.append(" column=\"").append(location.getColumn()).append("\"");
}
out.append(">\n");
out.append(">");
out.append(e(message));
compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompileEnvironmentConfiguration.java
+36
View File
@@ -0,0 +1,36 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.cli.js;
import com.intellij.openapi.util.Disposer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.CompileEnvironmentConfiguration;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
/**
* @author Pavel Talanov
*/
public class K2JSCompileEnvironmentConfiguration extends CompileEnvironmentConfiguration {
/**
* NOTE: It's very important to call dispose for every object of this class or there will be memory leaks.
*
* @see Disposer
*/
public K2JSCompileEnvironmentConfiguration(@NotNull MessageCollector messageCollector) {
super(messageCollector);
}
}
compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java
+73 -2
View File
@@ -16,12 +16,83 @@
package org.jetbrains.jet.cli.js;
import com.google.common.base.Predicates;
import com.intellij.openapi.Disposable;
import com.intellij.psi.PsiFile;
import jet.Function0;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.common.CLICompiler;
import org.jetbrains.jet.cli.common.ExitCode;
import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport;
import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity;
import org.jetbrains.jet.cli.common.messages.MessageRenderer;
import org.jetbrains.jet.cli.common.messages.PrintingMessageCollector;
import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import org.jetbrains.k2js.analyze.AnalyzerFacadeForJS;
import org.jetbrains.k2js.config.Config;
import java.io.PrintStream;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.jet.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
/**
* @author Pavel Talanov
*/
public final class K2JSCompiler {
public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments, K2JSCompileEnvironmentConfiguration> {
public static void main(String... args) {
//TODO
doMain(new K2JSCompiler(), args);
}
@NotNull
@Override
protected K2JSCompilerArguments createArguments() {
return new K2JSCompilerArguments();
}
@NotNull
@Override
protected ExitCode doExecute(PrintStream stream, K2JSCompilerArguments arguments, MessageRenderer renderer) {
PrintingMessageCollector messageCollector = new PrintingMessageCollector(stream, renderer, true);
if (arguments.module != null) {
stream.print(renderer.render(CompilerMessageSeverity.ERROR, "Module arg is not supported", NO_LOCATION));
return ExitCode.INTERNAL_ERROR;
}
if (arguments.srcdir == null) {
stream.print(renderer.render(CompilerMessageSeverity.ERROR, "Specify sources location via -srcdir", NO_LOCATION));
return ExitCode.INTERNAL_ERROR;
}
Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable();
final JetCoreEnvironment environmentForJS = JetCoreEnvironment.getCoreEnvironmentForJS(rootDisposable);
environmentForJS.addSources(arguments.srcdir);
AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(messageCollector);
final List<JetFile> sources = environmentForJS.getSourceFiles();
analyzerWithCompilerReport.analyzeAndReport(new Function0<AnalyzeExhaust>() {
@Override
public AnalyzeExhaust invoke() {
BindingContext context = AnalyzerFacadeForJS
.analyzeFiles(sources, Predicates.<PsiFile>alwaysTrue(), new Config(environmentForJS.getProject()) {
@NotNull
@Override
protected List<JetFile> generateLibFiles() {
return Collections.emptyList();
}
});
return AnalyzeExhaust.success(context, JetStandardLibrary.getInstance());
}
}, sources);
stream.print(renderer.render(CompilerMessageSeverity.ERROR, "Greeting", NO_LOCATION));
return ExitCode.OK;
}
}
compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompilerArguments.java
+39 -2
View File
@@ -16,9 +16,46 @@
package org.jetbrains.jet.cli.js;
import com.sampullara.cli.Argument;
import org.jetbrains.jet.cli.common.CompilerArguments;
/**
* @author Pavel Talanov
*/
//TODO
public class K2JSCompilerArguments {
public class K2JSCompilerArguments extends CompilerArguments {
@Argument(value = "output", description = "Output directory")
public String outputDir;
@Argument(value = "module", description = "Module to compile")
public String module;
@Argument(value = "srcdir", description = "Sources directory")
public String srcdir;
@Argument(value = "tags", description = "Demarcate each compilation message (error, warning, etc) with an open and close tag")
public boolean tags;
@Argument(value = "verbose", description = "Enable verbose logging output")
public boolean verbose;
@Argument(value = "version", description = "Display compiler version")
public boolean version;
@Argument(value = "help", alias = "h", description = "show help")
public boolean help;
@Override
public boolean isHelp() {
return help;
}
@Override
public boolean isTags() {
return tags;
}
@Override
public boolean isVersion() {
return version;
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompiler.java
+102 -166
View File
@@ -20,15 +20,16 @@ import com.google.common.base.Splitter;
import com.google.common.collect.Iterables;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.util.Disposer;
import com.sampullara.cli.Args;
import jet.modules.Module;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.CompilerPlugin;
import org.jetbrains.jet.cli.common.CLICompiler;
import org.jetbrains.jet.cli.common.ExitCode;
import org.jetbrains.jet.cli.common.messages.PrintingMessageCollector;
import org.jetbrains.jet.codegen.CompilationException;
import org.jetbrains.jet.cli.jvm.compiler.*;
import org.jetbrains.jet.cli.common.messages.*;
import org.jetbrains.jet.cli.jvm.compiler.K2JVMCompileEnvironmentConfiguration;
import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
import org.jetbrains.jet.codegen.CompilationException;
import org.jetbrains.jet.lang.resolve.java.CompilerDependencies;
import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
import org.jetbrains.jet.utils.PathUtil;
@@ -44,138 +45,101 @@ import static org.jetbrains.jet.cli.common.ExitCode.*;
* @author alex.tkachman
*/
@SuppressWarnings("UseOfSystemOutOrSystemErr")
public class K2JVMCompiler {
public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments, K2JVMCompileEnvironmentConfiguration> {
public static void main(String... args) {
doMain(new K2JVMCompiler(), args);
}
/**
* Useful main for derived command line tools
*/
public static void doMain(K2JVMCompiler compiler, String[] args) {
try {
ExitCode rc = compiler.exec(System.out, args);
if (rc != OK) {
System.err.println("exec() finished with " + rc + " return code");
System.exit(rc.getCode());
@Override
@NotNull
protected ExitCode doExecute(PrintStream errStream,
K2JVMCompilerArguments arguments,
MessageRenderer messageRenderer) {
CompilerSpecialMode mode = parseCompilerSpecialMode(arguments);
File jdkHeadersJar;
if (mode.includeJdkHeaders()) {
if (arguments.jdkHeaders != null) {
jdkHeadersJar = new File(arguments.jdkHeaders);
}
else {
jdkHeadersJar = PathUtil.getAltHeadersPath();
}
}
catch (CompileEnvironmentException e) {
System.err.println(e.getMessage());
System.exit(INTERNAL_ERROR.getCode());
else {
jdkHeadersJar = null;
}
}
File runtimeJar;
public ExitCode exec(PrintStream errStream, String... args) {
K2JVMCompilerArguments arguments = createArguments();
if (!parseArguments(errStream, arguments, args)) {
if (mode.includeKotlinRuntime()) {
if (arguments.stdlib != null) {
runtimeJar = new File(arguments.stdlib);
}
else {
runtimeJar = PathUtil.getDefaultRuntimePath();
}
}
else {
runtimeJar = null;
}
CompilerDependencies dependencies = new CompilerDependencies(mode, CompilerDependencies.findRtJar(), jdkHeadersJar, runtimeJar);
PrintingMessageCollector messageCollector = new PrintingMessageCollector(errStream, messageRenderer, arguments.verbose);
Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable();
JetCoreEnvironment environment = JetCoreEnvironment.getCoreEnvironmentForJVM(rootDisposable, dependencies);
K2JVMCompileEnvironmentConfiguration configuration =
new K2JVMCompileEnvironmentConfiguration(environment, messageCollector);
messageCollector.report(CompilerMessageSeverity.LOGGING, "Configuring the compilation environment",
CompilerMessageLocation.NO_LOCATION);
try {
configureEnvironment(configuration, arguments);
boolean noErrors;
if (arguments.module != null) {
List<Module> modules = CompileEnvironmentUtil
.loadModuleScript(arguments.module, new PrintingMessageCollector(errStream, messageRenderer, false));
File directory = new File(arguments.module).getParentFile();
noErrors = KotlinToJVMBytecodeCompiler.compileModules(configuration, modules,
directory, arguments.jar, arguments.outputDir,
arguments.includeRuntime);
}
else {
// TODO ideally we'd unify to just having a single field that supports multiple files/dirs
if (arguments.getSourceDirs() != null) {
noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSourceDirectories(configuration,
arguments.getSourceDirs(), arguments.jar,
arguments.outputDir,
arguments.includeRuntime);
}
else {
noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSources(configuration,
arguments.src, arguments.jar, arguments.outputDir,
arguments.includeRuntime);
}
}
return noErrors ? OK : COMPILATION_ERROR;
}
catch (CompilationException e) {
messageCollector.report(CompilerMessageSeverity.EXCEPTION, MessageRenderer.PLAIN.renderException(e),
MessageUtil.psiElementToMessageLocation(e.getElement()));
return INTERNAL_ERROR;
}
return exec(errStream, arguments);
}
/**
* Executes the compiler on the parsed arguments
*/
public ExitCode exec(final PrintStream errStream, K2JVMCompilerArguments arguments) {
if (arguments.help) {
usage(errStream);
return OK;
}
System.setProperty("java.awt.headless", "true");
final MessageRenderer messageRenderer = arguments.tags ? MessageRenderer.TAGS : MessageRenderer.PLAIN;
errStream.print(messageRenderer.renderPreamble());
try {
if (arguments.version) {
errStream.println(messageRenderer.render(CompilerMessageSeverity.INFO, "Kotlin Compiler version " + K2JVMCompilerVersion.VERSION, CompilerMessageLocation.NO_LOCATION));
}
CompilerSpecialMode mode = parseCompilerSpecialMode(arguments);
File jdkHeadersJar;
if (mode.includeJdkHeaders()) {
if (arguments.jdkHeaders != null) {
jdkHeadersJar = new File(arguments.jdkHeaders);
}
else {
jdkHeadersJar = PathUtil.getAltHeadersPath();
}
}
else {
jdkHeadersJar = null;
}
File runtimeJar;
if (mode.includeKotlinRuntime()) {
if (arguments.stdlib != null) {
runtimeJar = new File(arguments.stdlib);
}
else {
runtimeJar = PathUtil.getDefaultRuntimePath();
}
}
else {
runtimeJar = null;
}
CompilerDependencies dependencies = new CompilerDependencies(mode, CompilerDependencies.findRtJar(), jdkHeadersJar, runtimeJar);
PrintingMessageCollector messageCollector = new PrintingMessageCollector(errStream, messageRenderer, arguments.verbose);
Disposable rootDisposable = CompileEnvironmentUtil.createMockDisposable();
JetCoreEnvironment environment = new JetCoreEnvironment(rootDisposable, dependencies);
CompileEnvironmentConfiguration configuration = new CompileEnvironmentConfiguration(environment, dependencies, messageCollector);
messageCollector.report(CompilerMessageSeverity.LOGGING, "Configuring the compilation environment",
catch (Throwable t) {
messageCollector.report(CompilerMessageSeverity.EXCEPTION, MessageRenderer.PLAIN.renderException(t),
CompilerMessageLocation.NO_LOCATION);
try {
configureEnvironment(configuration, arguments);
boolean noErrors;
if (arguments.module != null) {
List<Module> modules = CompileEnvironmentUtil.loadModuleScript(arguments.module, new PrintingMessageCollector(errStream, messageRenderer, false));
File directory = new File(arguments.module).getParentFile();
noErrors = KotlinToJVMBytecodeCompiler.compileModules(configuration, modules,
directory, arguments.jar, arguments.outputDir,
arguments.includeRuntime);
}
else {
// TODO ideally we'd unify to just having a single field that supports multiple files/dirs
if (arguments.getSourceDirs() != null) {
noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSourceDirectories(configuration,
arguments.getSourceDirs(), arguments.jar, arguments.outputDir, arguments.includeRuntime);
}
else {
noErrors = KotlinToJVMBytecodeCompiler.compileBunchOfSources(configuration,
arguments.src, arguments.jar, arguments.outputDir, arguments.includeRuntime);
}
}
return noErrors ? OK : COMPILATION_ERROR;
}
catch (CompilationException e) {
messageCollector.report(CompilerMessageSeverity.EXCEPTION, MessageRenderer.PLAIN.renderException(e),
MessageUtil.psiElementToMessageLocation(e.getElement()));
return INTERNAL_ERROR;
}
catch (Throwable t) {
messageCollector.report(CompilerMessageSeverity.EXCEPTION, MessageRenderer.PLAIN.renderException(t), CompilerMessageLocation.NO_LOCATION);
return INTERNAL_ERROR;
}
finally {
Disposer.dispose(rootDisposable);
messageCollector.printToErrStream();
}
return INTERNAL_ERROR;
}
finally {
errStream.print(messageRenderer.renderConclusion());
Disposer.dispose(rootDisposable);
messageCollector.printToErrStream();
}
}
@NotNull
private CompilerSpecialMode parseCompilerSpecialMode(@NotNull K2JVMCompilerArguments arguments) {
private static CompilerSpecialMode parseCompilerSpecialMode(@NotNull K2JVMCompilerArguments arguments) {
if (arguments.mode == null) {
return CompilerSpecialMode.REGULAR;
}
@@ -190,65 +154,37 @@ public class K2JVMCompiler {
throw new IllegalArgumentException("unknown compiler mode: " + arguments.mode);
}
/**
* Returns true if the arguments can be parsed correctly
*/
protected boolean parseArguments(PrintStream errStream, K2JVMCompilerArguments arguments, String[] args) {
try {
Args.parse(arguments, args);
return true;
}
catch (IllegalArgumentException e) {
usage(errStream);
}
catch (Throwable t) {
// Always use tags
errStream.println(MessageRenderer.TAGS.renderException(t));
}
return false;
}
protected void usage(PrintStream target) {
// We should say something like
// Args.usage(target, K2JVMCompilerArguments.class);
// but currently cli-parser we are using does not support that
// a corresponding patch has been sent to the authors
// For now, we are using this:
PrintStream oldErr = System.err;
System.setErr(target);
try {
// TODO: use proper argv0
Args.usage(new K2JVMCompilerArguments());
} finally {
System.setErr(oldErr);
}
}
/**
* Allow derived classes to add additional command line arguments
*/
@NotNull
@Override
protected K2JVMCompilerArguments createArguments() {
return new K2JVMCompilerArguments();
}
/**
* Strategy method to configure the environment, allowing compiler
* based tools to customise their own plugins
*/
protected void configureEnvironment(CompileEnvironmentConfiguration configuration, K2JVMCompilerArguments arguments) {
// install any compiler plugins
List<CompilerPlugin> plugins = arguments.getCompilerPlugins();
if (plugins != null) {
configuration.getCompilerPlugins().addAll(plugins);
}
//TODO: Hacked! Be sure that our kotlin stuff builds correctly before you remove.
// our compiler throws method not found error
// probably relates to KT-1863... well, may be not
@NotNull
@Override
public ExitCode exec(PrintStream errStream, K2JVMCompilerArguments arguments) {
return super.exec(errStream, arguments);
}
if (configuration.getCompilerDependencies().getRuntimeJar() != null) {
CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(), configuration.getCompilerDependencies().getRuntimeJar());
@Override
protected void configureEnvironment(@NotNull K2JVMCompileEnvironmentConfiguration configuration, @NotNull K2JVMCompilerArguments arguments) {
super.configureEnvironment(configuration, arguments);
if (configuration.getEnvironment().getCompilerDependencies().getRuntimeJar() != null) {
CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(),
configuration.getEnvironment().getCompilerDependencies().getRuntimeJar());
}
if (arguments.classpath != null) {
final Iterable<String> classpath = Splitter.on(File.pathSeparatorChar).split(arguments.classpath);
Iterable<String> classpath = Splitter.on(File.pathSeparatorChar).split(arguments.classpath);
CompileEnvironmentUtil.addToClasspath(configuration.getEnvironment(), Iterables.toArray(classpath, String.class));
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/K2JVMCompilerArguments.java
+18 -24
View File
@@ -18,16 +18,15 @@
package org.jetbrains.jet.cli.jvm;
import com.sampullara.cli.Argument;
import org.jetbrains.jet.cli.common.CompilerPlugin;
import org.jetbrains.jet.cli.common.CompilerArguments;
import java.util.ArrayList;
import java.util.List;
/**
* Command line arguments for the {@link K2JVMCompiler}
*/
public class K2JVMCompilerArguments {
private List<CompilerPlugin> compilerPlugins = new ArrayList<CompilerPlugin>();
public class K2JVMCompilerArguments extends CompilerArguments {
// TODO ideally we'd unify this with 'src' to just having a single field that supports multiple files/dirs
private List<String> sourceDirs;
@@ -40,18 +39,12 @@ public class K2JVMCompilerArguments {
this.sourceDirs = sourceDirs;
}
@Argument(value = "output", description = "output directory")
public String outputDir;
@Argument(value = "jar", description = "jar file name")
public String jar;
@Argument(value = "src", description = "source file or directory")
public String src;
@Argument(value = "module", description = "module to compile")
public String module;
@Argument(value = "classpath", description = "classpath to use when compiling")
public String classpath;
@@ -64,12 +57,15 @@ public class K2JVMCompilerArguments {
@Argument(value = "jdkHeaders", description = "Path to the kotlin-jdk-headers.jar")
public String jdkHeaders;
@Argument(value = "help", alias = "h", description = "show help")
public boolean help;
@Argument(value = "mode", description = "Special compiler modes: stubs or jdkHeaders")
public String mode;
@Argument(value = "output", description = "output directory")
public String outputDir;
@Argument(value = "module", description = "module to compile")
public String module;
@Argument(value = "tags", description = "Demarcate each compilation message (error, warning, etc) with an open and close tag")
public boolean tags;
@@ -79,6 +75,8 @@ public class K2JVMCompilerArguments {
@Argument(value = "version", description = "Display compiler version")
public boolean version;
@Argument(value = "help", alias = "h", description = "show help")
public boolean help;
public String getClasspath() {
return classpath;
@@ -88,6 +86,7 @@ public class K2JVMCompilerArguments {
this.classpath = classpath;
}
@Override
public boolean isHelp() {
return help;
}
@@ -144,22 +143,17 @@ public class K2JVMCompilerArguments {
this.stdlib = stdlib;
}
@Override
public boolean isTags() {
return tags;
}
@Override
public boolean isVersion() {
return version;
}
public void setTags(boolean tags) {
this.tags = tags;
}
public List<CompilerPlugin> getCompilerPlugins() {
return compilerPlugins;
}
/**
* Sets the compiler plugins to be used when working with the {@link K2JVMCompiler}
*/
public void setCompilerPlugins(List<CompilerPlugin> compilerPlugins) {
this.compilerPlugins = compilerPlugins;
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java
+23 -5
View File
@@ -24,6 +24,7 @@ import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.Processor;
import jet.modules.AllModules;
import jet.modules.Module;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
import org.jetbrains.jet.codegen.ClassFileFactory;
@@ -61,7 +62,7 @@ public class CompileEnvironmentUtil {
@Nullable
public static File getUnpackedRuntimePath() {
URL url = CompileEnvironmentConfiguration.class.getClassLoader().getResource("jet/JetObject.class");
URL url = K2JVMCompileEnvironmentConfiguration.class.getClassLoader().getResource("jet/JetObject.class");
if (url != null && url.getProtocol().equals("file")) {
return new File(url.getPath()).getParentFile().getParentFile();
}
@@ -70,7 +71,7 @@ public class CompileEnvironmentUtil {
@Nullable
public static File getRuntimeJarPath() {
URL url = CompileEnvironmentConfiguration.class.getClassLoader().getResource("jet/JetObject.class");
URL url = K2JVMCompileEnvironmentConfiguration.class.getClassLoader().getResource("jet/JetObject.class");
if (url != null && url.getProtocol().equals("jar")) {
String path = url.getPath();
return new File(path.substring(path.indexOf(":") + 1, path.indexOf("!/")));
@@ -157,12 +158,12 @@ public class CompileEnvironmentUtil {
}
};
CompilerDependencies dependencies = CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.REGULAR);
JetCoreEnvironment scriptEnvironment = new JetCoreEnvironment(disposable, dependencies);
JetCoreEnvironment scriptEnvironment = JetCoreEnvironment.getCoreEnvironmentForJVM(disposable, dependencies);
ensureRuntime(scriptEnvironment, dependencies);
scriptEnvironment.addSources(moduleScriptFile);
GenerationState generationState = KotlinToJVMBytecodeCompiler
.analyzeAndGenerate(new CompileEnvironmentConfiguration(scriptEnvironment, dependencies, messageCollector), false);
.analyzeAndGenerate(new K2JVMCompileEnvironmentConfiguration(scriptEnvironment, messageCollector), false);
if (generationState == null) {
return null;
}
@@ -194,7 +195,7 @@ public class CompileEnvironmentUtil {
}
}
else {
loader = new GeneratedClassLoader(factory, CompileEnvironmentConfiguration.class.getClassLoader());
loader = new GeneratedClassLoader(factory, K2JVMCompileEnvironmentConfiguration.class.getClassLoader());
}
try {
Class namespaceClass = loader.loadClass(JvmAbi.PACKAGE_CLASS);
@@ -337,4 +338,21 @@ public class CompileEnvironmentUtil {
addToClasspath(environment, new File(path));
}
}
public static void addSourcesFromModuleToEnvironment(@NotNull JetCoreEnvironment environment,
@NotNull Module module,
@NotNull File moduleDirectory) {
for (String sourceFile : module.getSourceFiles()) {
File source = new File(sourceFile);
if (!source.isAbsolute()) {
source = new File(moduleDirectory, sourceFile);
}
if (!source.exists()) {
throw new CompileEnvironmentException("'" + source + "' does not exist");
}
environment.addSources(source.getPath());
}
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java
+34 -12
View File
@@ -47,8 +47,24 @@ import java.util.List;
public class JetCoreEnvironment extends JavaCoreEnvironment {
private final List<JetFile> sourceFiles = new ArrayList<JetFile>();
@NotNull
public static JetCoreEnvironment getCoreEnvironmentForJS(Disposable disposable) {
return new JetCoreEnvironment(disposable, CompilerDependencies.compilerDependenciesForProduction(CompilerSpecialMode.JS));
}
@NotNull
public static JetCoreEnvironment getCoreEnvironmentForJVM(Disposable disposable, @NotNull CompilerDependencies dependencies) {
return new JetCoreEnvironment(disposable, dependencies);
}
@NotNull
private final CompilerDependencies compilerDependencies;
public JetCoreEnvironment(Disposable parentDisposable, @NotNull CompilerDependencies compilerDependencies) {
super(parentDisposable);
this.compilerDependencies = compilerDependencies;
registerFileType(JetFileType.INSTANCE, "kt");
registerFileType(JetFileType.INSTANCE, "kts");
registerFileType(JetFileType.INSTANCE, "ktm");
@@ -72,9 +88,7 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
}
}
if (compilerSpecialMode.includeKotlinRuntime()) {
for (VirtualFile root : compilerDependencies.getRuntimeRoots()) {
addLibraryRoot(root);
}
addToClasspath(compilerDependencies.getRuntimeJar());
}
JetStandardLibrary.initialize(getProject());
@@ -85,7 +99,7 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
}
private void addSources(File file) {
if(file.isDirectory()) {
if (file.isDirectory()) {
File[] files = file.listFiles();
if (files != null) {
for (File child : files) {
@@ -97,15 +111,15 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
VirtualFile fileByPath = getLocalFileSystem().findFileByPath(file.getAbsolutePath());
if (fileByPath != null) {
PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(fileByPath);
if(psiFile instanceof JetFile) {
sourceFiles.add((JetFile)psiFile);
if (psiFile instanceof JetFile) {
sourceFiles.add((JetFile) psiFile);
}
}
}
}
public void addSources(VirtualFile vFile) {
if (vFile.isDirectory()) {
if (vFile.isDirectory()) {
for (VirtualFile virtualFile : vFile.getChildren()) {
addSources(virtualFile);
}
@@ -114,15 +128,16 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
if (vFile.getFileType() == JetFileType.INSTANCE) {
PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(vFile);
if (psiFile instanceof JetFile) {
sourceFiles.add((JetFile)psiFile);
sourceFiles.add((JetFile) psiFile);
}
}
}
}
public void addSources(String path) {
if(path == null)
if (path == null) {
return;
}
VirtualFile vFile = getLocalFileSystem().findFileByPath(path);
if (vFile == null) {
@@ -141,15 +156,22 @@ public class JetCoreEnvironment extends JavaCoreEnvironment {
public void addToClasspathFromClassLoader(ClassLoader loader) {
ClassLoader parent = loader.getParent();
if(parent != null)
if (parent != null) {
addToClasspathFromClassLoader(parent);
}
if(loader instanceof URLClassLoader) {
if (loader instanceof URLClassLoader) {
for (URL url : ((URLClassLoader) loader).getURLs()) {
File file = new File(url.getPath());
if(file.exists() && (!file.isFile() || file.getPath().endsWith(".jar")))
if (file.exists() && (!file.isFile() || file.getPath().endsWith(".jar"))) {
addToClasspath(file);
}
}
}
}
@NotNull
public CompilerDependencies getCompilerDependencies() {
return compilerDependencies;
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/K2JVMCompileEnvironmentConfiguration.java
+44
View File
@@ -0,0 +1,44 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.cli.jvm.compiler;
import com.intellij.openapi.util.Disposer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.cli.common.CompileEnvironmentConfiguration;
import org.jetbrains.jet.cli.common.messages.MessageCollector;
/**
* @author abreslav
*/
public class K2JVMCompileEnvironmentConfiguration extends CompileEnvironmentConfiguration {
private final JetCoreEnvironment environment;
/**
* NOTE: It's very important to call dispose for every object of this class or there will be memory leaks.
*
* @see Disposer
*/
public K2JVMCompileEnvironmentConfiguration(@NotNull JetCoreEnvironment environment,
@NotNull MessageCollector messageCollector) {
super(messageCollector);
this.environment = environment;
}
public JetCoreEnvironment getEnvironment() {
return environment;
}
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
+18 -29
View File
@@ -59,7 +59,7 @@ public class KotlinToJVMBytecodeCompiler {
@Nullable
public static ClassFileFactory compileModule(
CompileEnvironmentConfiguration configuration,
K2JVMCompileEnvironmentConfiguration configuration,
Module moduleBuilder,
File directory
) {
@@ -67,23 +67,12 @@ public class KotlinToJVMBytecodeCompiler {
throw new CompileEnvironmentException("No source files where defined");
}
for (String sourceFile : moduleBuilder.getSourceFiles()) {
File source = new File(sourceFile);
if (!source.isAbsolute()) {
source = new File(directory, sourceFile);
}
if (!source.exists()) {
throw new CompileEnvironmentException("'" + source + "' does not exist");
}
configuration.getEnvironment().addSources(source.getPath());
}
CompileEnvironmentUtil.addSourcesFromModuleToEnvironment(configuration.getEnvironment(), moduleBuilder, directory);
for (String classpathRoot : moduleBuilder.getClasspathRoots()) {
configuration.getEnvironment().addToClasspath(new File(classpathRoot));
}
CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getCompilerDependencies());
CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getEnvironment().getCompilerDependencies());
GenerationState generationState = analyzeAndGenerate(configuration);
if (generationState == null) {
@@ -93,7 +82,7 @@ public class KotlinToJVMBytecodeCompiler {
}
public static boolean compileModules(
CompileEnvironmentConfiguration configuration,
K2JVMCompileEnvironmentConfiguration configuration,
@NotNull List<Module> modules,
@@ -104,9 +93,9 @@ public class KotlinToJVMBytecodeCompiler {
for (Module moduleBuilder : modules) {
// TODO: this should be done only once for the environment
if (configuration.getCompilerDependencies().getRuntimeJar() != null) {
if (configuration.getEnvironment().getCompilerDependencies().getRuntimeJar() != null) {
CompileEnvironmentUtil
.addToClasspath(configuration.getEnvironment(), configuration.getCompilerDependencies().getRuntimeJar());
.addToClasspath(configuration.getEnvironment(), configuration.getEnvironment().getCompilerDependencies().getRuntimeJar());
}
ClassFileFactory moduleFactory = compileModule(configuration, moduleBuilder, directory);
if (moduleFactory == null) {
@@ -129,7 +118,7 @@ public class KotlinToJVMBytecodeCompiler {
}
private static boolean compileBunchOfSources(
CompileEnvironmentConfiguration configuration,
K2JVMCompileEnvironmentConfiguration configuration,
String jar,
String outputDir,
boolean includeRuntime
@@ -143,7 +132,7 @@ public class KotlinToJVMBytecodeCompiler {
}
}
CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getCompilerDependencies());
CompileEnvironmentUtil.ensureRuntime(configuration.getEnvironment(), configuration.getEnvironment().getCompilerDependencies());
GenerationState generationState = analyzeAndGenerate(configuration);
if (generationState == null) {
@@ -174,7 +163,7 @@ public class KotlinToJVMBytecodeCompiler {
}
public static boolean compileBunchOfSources(
CompileEnvironmentConfiguration configuration,
K2JVMCompileEnvironmentConfiguration configuration,
String sourceFileOrDir, String jar, String outputDir, boolean includeRuntime) {
configuration.getEnvironment().addSources(sourceFileOrDir);
@@ -183,7 +172,7 @@ public class KotlinToJVMBytecodeCompiler {
}
public static boolean compileBunchOfSourceDirectories(
CompileEnvironmentConfiguration configuration,
K2JVMCompileEnvironmentConfiguration configuration,
List<String> sources, String jar, String outputDir, boolean includeRuntime) {
for (String source : sources) {
@@ -195,7 +184,7 @@ public class KotlinToJVMBytecodeCompiler {
@Nullable
public static ClassLoader compileText(
CompileEnvironmentConfiguration configuration,
K2JVMCompileEnvironmentConfiguration configuration,
String code) {
configuration.getEnvironment()
.addSources(new LightVirtualFile("script" + LocalTimeCounter.currentTime() + ".kt", JetLanguage.INSTANCE, code));
@@ -208,13 +197,13 @@ public class KotlinToJVMBytecodeCompiler {
}
@Nullable
public static GenerationState analyzeAndGenerate(CompileEnvironmentConfiguration configuration) {
return analyzeAndGenerate(configuration, configuration.getCompilerDependencies().getCompilerSpecialMode().isStubs());
public static GenerationState analyzeAndGenerate(K2JVMCompileEnvironmentConfiguration configuration) {
return analyzeAndGenerate(configuration, configuration.getEnvironment().getCompilerDependencies().getCompilerSpecialMode().isStubs());
}
@Nullable
public static GenerationState analyzeAndGenerate(
CompileEnvironmentConfiguration configuration,
K2JVMCompileEnvironmentConfiguration configuration,
boolean stubs
) {
AnalyzeExhaust exhaust = analyze(configuration, stubs);
@@ -230,7 +219,7 @@ public class KotlinToJVMBytecodeCompiler {
@Nullable
private static AnalyzeExhaust analyze(
final CompileEnvironmentConfiguration configuration,
final K2JVMCompileEnvironmentConfiguration configuration,
boolean stubs) {
final JetCoreEnvironment environment = configuration.getEnvironment();
AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(configuration.getMessageCollector());
@@ -244,7 +233,7 @@ public class KotlinToJVMBytecodeCompiler {
return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
environment.getProject(), environment.getSourceFiles(), filesToAnalyzeCompletely,
JetControlFlowDataTraceFactory.EMPTY,
configuration.getCompilerDependencies());
configuration.getEnvironment().getCompilerDependencies());
}
}, environment.getSourceFiles()
);
@@ -254,7 +243,7 @@ public class KotlinToJVMBytecodeCompiler {
@NotNull
private static GenerationState generate(
final CompileEnvironmentConfiguration configuration,
final K2JVMCompileEnvironmentConfiguration configuration,
AnalyzeExhaust exhaust,
boolean stubs) {
JetCoreEnvironment environment = configuration.getEnvironment();
@@ -267,7 +256,7 @@ public class KotlinToJVMBytecodeCompiler {
};
GenerationState generationState = new GenerationState(project, ClassBuilderFactories.binaries(stubs), backendProgress,
exhaust, environment.getSourceFiles(),
configuration.getCompilerDependencies().getCompilerSpecialMode());
configuration.getEnvironment().getCompilerDependencies().getCompilerSpecialMode());
generationState.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
List<CompilerPlugin> plugins = configuration.getCompilerPlugins();
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/CompilerSpecialMode.java
+1
View File
@@ -24,6 +24,7 @@ public enum CompilerSpecialMode {
BUILTINS,
JDK_HEADERS,
STDLIB,
JS
;
public boolean includeJdkHeaders() {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+75 -48
View File
@@ -92,11 +92,7 @@ import org.jetbrains.jet.lang.resolve.constants.NullValue;
import org.jetbrains.jet.lang.resolve.constants.ShortValue;
import org.jetbrains.jet.lang.resolve.constants.StringValue;
import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.Variance;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import org.jetbrains.jet.rt.signature.JetSignatureAdapter;
@@ -222,14 +218,14 @@ public class JavaDescriptorResolver {
throw new IllegalStateException("both psiClass and psiPackage cannot be null");
}
if (fqName.lastSegmentIs(JvmAbi.PACKAGE_CLASS)) {
throw new IllegalStateException("identified cannot have last segment " + JvmAbi.PACKAGE_CLASS + ": " + fqName);
}
this.staticMembers = staticMembers;
this.kotlin = psiClass != null &&
(new PsiClassWrapper(psiClass).getJetClass().isDefined() || psiClass.getName().equals(JvmAbi.PACKAGE_CLASS));
classOrNamespaceDescriptor = descriptor;
if (fqName.lastSegmentIs(JvmAbi.PACKAGE_CLASS) && psiClass != null && kotlin) {
throw new IllegalStateException("Kotlin namespace cannot have last segment " + JvmAbi.PACKAGE_CLASS + ": " + fqName);
}
}
protected ResolverScopeData(boolean negative) {
@@ -356,6 +352,15 @@ public class JavaDescriptorResolver {
@Nullable
private ClassDescriptor resolveJavaLangObject() {
ClassDescriptor clazz = resolveClass(JdkNames.JL_OBJECT.getFqName(), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
if (clazz == null) {
// TODO: warning
}
return clazz;
}
@Nullable
public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
List<Runnable> tasks = Lists.newArrayList();
@@ -466,7 +471,7 @@ public class JavaDescriptorResolver {
"class " + psiClass.getQualifiedName());
// TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData.classDescriptor, classData.getTypeParameters()));
supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData, classData.getTypeParameters()));
PsiMethod[] psiConstructors = psiClass.getConstructors();
@@ -530,28 +535,7 @@ public class JavaDescriptorResolver {
}
else {
for (PsiMethod psiConstructor : psiConstructors) {
PsiMethodWrapper constructor = new PsiMethodWrapper(psiConstructor);
if (constructor.getJetConstructor().hidden()) {
continue;
}
ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
classData.classDescriptor,
Collections.<AnnotationDescriptor>emptyList(), // TODO
false);
String context = "constructor of class " + psiClass.getQualifiedName();
ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor,
constructor.getParameters(),
TypeVariableResolvers.classTypeVariableResolver(classData.classDescriptor, context));
if (valueParameterDescriptors.receiverType != null) {
throw new IllegalStateException();
}
constructorDescriptor.initialize(typeParameters, valueParameterDescriptors.descriptors,
resolveVisibilityFromPsiModifiers(psiConstructor), isStatic);
constructorDescriptor.setReturnType(classData.classDescriptor.getDefaultType());
classData.classDescriptor.addConstructor(constructorDescriptor, null);
trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
resolveConstructor(psiClass, classData, isStatic, psiConstructor);
}
}
@@ -565,6 +549,32 @@ public class JavaDescriptorResolver {
return classData;
}
private void resolveConstructor(PsiClass psiClass, ResolverBinaryClassData classData, boolean aStatic, PsiMethod psiConstructor) {
PsiMethodWrapper constructor = new PsiMethodWrapper(psiConstructor);
if (constructor.getJetConstructor().hidden()) {
return;
}
ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
classData.classDescriptor,
Collections.<AnnotationDescriptor>emptyList(), // TODO
false);
String context = "constructor of class " + psiClass.getQualifiedName();
ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor,
constructor.getParameters(),
TypeVariableResolvers.classTypeVariableResolver(classData.classDescriptor, context));
if (valueParameterDescriptors.receiverType != null) {
throw new IllegalStateException();
}
constructorDescriptor.initialize(classData.classDescriptor.getTypeConstructor().getParameters(),
valueParameterDescriptors.descriptors,
resolveVisibilityFromPsiModifiers(psiConstructor), aStatic);
constructorDescriptor.setReturnType(classData.classDescriptor.getDefaultType());
classData.classDescriptor.addConstructor(constructorDescriptor, null);
trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
}
static void checkPsiClassIsNotJet(PsiClass psiClass) {
if (psiClass instanceof JetJavaMirrorMarker) {
throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass: " + psiClass.getQualifiedName());
@@ -599,7 +609,7 @@ public class JavaDescriptorResolver {
classDescriptorCache.put(fqName, classData);
classData.classDescriptor.setSupertypes(getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData.classDescriptor, new ArrayList<TypeParameterDescriptor>(0)));
classData.classDescriptor.setSupertypes(getSupertypes(new PsiClassWrapper(classObjectPsiClass), classData, new ArrayList<TypeParameterDescriptor>(0)));
classData.classDescriptor.setName(JetPsiUtil.NO_NAME_PROVIDED); // TODO
classData.classDescriptor.setModality(Modality.FINAL);
classData.classDescriptor.setVisibility(containing.getVisibility());
@@ -855,14 +865,22 @@ public class JavaDescriptorResolver {
private void initializeTypeParameters(List<TypeParameterDescriptorInitialization> typeParametersInitialization, @NotNull DeclarationDescriptor typeParametersOwner, @NotNull String context) {
List<TypeParameterDescriptor> prevTypeParameters = new ArrayList<TypeParameterDescriptor>();
List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
for (TypeParameterDescriptorInitialization typeParameterDescriptor : typeParametersInitialization) {
typeParameters.add(typeParameterDescriptor.descriptor);
}
for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
prevTypeParameters.add(psiTypeParameter.descriptor);
initializeTypeParameter(psiTypeParameter,
TypeVariableResolvers.typeVariableResolverFromTypeParameters(prevTypeParameters, typeParametersOwner, context));
TypeVariableResolvers.typeVariableResolverFromTypeParameters(typeParameters, typeParametersOwner, context));
}
}
private Collection<JetType> getSupertypes(PsiClassWrapper psiClass, ClassDescriptor classDescriptor, List<TypeParameterDescriptor> typeParameters) {
private Collection<JetType> getSupertypes(PsiClassWrapper psiClass, ResolverBinaryClassData classData, List<TypeParameterDescriptor> typeParameters) {
ClassDescriptor classDescriptor = classData.classDescriptor;
final List<JetType> result = new ArrayList<JetType>();
String context = "class " + psiClass.getQualifiedName();
@@ -908,7 +926,21 @@ public class JavaDescriptorResolver {
}
if (result.isEmpty()) {
result.add(JetStandardClasses.getAnyType());
if (classData.kotlin
|| psiClass.getQualifiedName().equals(JdkNames.JL_OBJECT.getFqName().getFqName())
// TODO: annotations
|| classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) {
result.add(JetStandardClasses.getAnyType());
}
else {
ClassDescriptor object = resolveJavaLangObject();
if (object != null) {
result.add(object.getDefaultType());
}
else {
result.add(JetStandardClasses.getAnyType());
}
}
}
return result;
}
@@ -923,7 +955,7 @@ public class JavaDescriptorResolver {
continue;
}
JetType transform = semanticServices.getTypeTransformer().transformToType(type, typeVariableResolver);
JetType transform = semanticServices.getTypeTransformer().transformToType(type, JavaTypeTransformer.TypeUsage.SUPERTYPE, typeVariableResolver);
result.add(TypeUtils.makeNotNullable(transform));
}
@@ -1120,7 +1152,7 @@ public class JavaDescriptorResolver {
JetType varargElementType;
if (psiType instanceof PsiEllipsisType) {
varargElementType = JetStandardLibrary.getInstance().getArrayElementType(outType);
varargElementType = JetStandardLibrary.getInstance().getArrayElementType(TypeUtils.makeNotNullable(outType));
}
else {
varargElementType = null;
@@ -1239,8 +1271,6 @@ public class JavaDescriptorResolver {
namedMembers.propertyAccessors = Collections.emptyList();
}
TypeVariableResolver typeVariableResolver = TypeVariableResolvers.classTypeVariableResolver(owner, context);
class GroupingValue {
PropertyAccessorData getter;
PropertyAccessorData setter;
@@ -1381,14 +1411,14 @@ public class JavaDescriptorResolver {
PsiMethodWrapper method = (PsiMethodWrapper) members.setter.getMember();
if (anyMember == members.setter) {
typeParameters = resolveMethodTypeParameters(method, propertyDescriptor, typeVariableResolver);
typeParameters = resolveMethodTypeParameters(method, propertyDescriptor);
}
}
if (members.getter != null) {
PsiMethodWrapper method = (PsiMethodWrapper) members.getter.getMember();
if (anyMember == members.getter) {
typeParameters = resolveMethodTypeParameters(method, propertyDescriptor, typeVariableResolver);
typeParameters = resolveMethodTypeParameters(method, propertyDescriptor);
}
}
@@ -1549,7 +1579,7 @@ public class JavaDescriptorResolver {
private TypeSubstitutor createSubstitutorForGenericSupertypes(@Nullable ClassDescriptor classDescriptor) {
TypeSubstitutor typeSubstitutor;
if (classDescriptor != null) {
typeSubstitutor = TypeUtils.buildDeepSubstitutor(classDescriptor.getDefaultType());
typeSubstitutor = SubstitutionUtils.buildDeepSubstitutor(classDescriptor.getDefaultType());
}
else {
typeSubstitutor = TypeSubstitutor.EMPTY;
@@ -1617,9 +1647,7 @@ public class JavaDescriptorResolver {
String context = "method " + method.getName() + " in class " + psiClass.getQualifiedName();
final TypeVariableResolver typeVariableResolverForParameters = TypeVariableResolvers.classTypeVariableResolver(scopeData.classOrNamespaceDescriptor, context);
final List<TypeParameterDescriptor> methodTypeParameters = resolveMethodTypeParameters(method, functionDescriptorImpl, typeVariableResolverForParameters);
final List<TypeParameterDescriptor> methodTypeParameters = resolveMethodTypeParameters(method, functionDescriptorImpl);
TypeVariableResolver methodTypeVariableResolver = TypeVariableResolvers.typeVariableResolverFromTypeParameters(methodTypeParameters, functionDescriptorImpl, context);
@@ -1760,8 +1788,7 @@ public class JavaDescriptorResolver {
private List<TypeParameterDescriptor> resolveMethodTypeParameters(
@NotNull PsiMethodWrapper method,
@NotNull DeclarationDescriptor functionDescriptor,
@NotNull TypeVariableResolver classTypeVariableResolver) {
@NotNull DeclarationDescriptor functionDescriptor) {
List<TypeParameterDescriptorInitialization> typeParametersIntialization;
if (method.getJetMethod().typeParameters().length() > 0) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
+43 -20
View File
@@ -17,6 +17,7 @@
package org.jetbrains.jet.lang.resolve.java;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.intellij.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -25,16 +26,16 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.FqName;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import org.jetbrains.jet.lang.types.lang.PrimitiveType;
import org.jetbrains.jet.rt.signature.JetSignatureReader;
import javax.inject.Inject;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import static org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer.TypeUsage.*;
/**
* @author abreslav
@@ -63,9 +64,11 @@ public class JavaTypeTransformer {
@NotNull
public TypeProjection transformToTypeProjection(@NotNull final PsiType javaType,
private TypeProjection transformToTypeProjection(@NotNull final PsiType javaType,
@NotNull final TypeParameterDescriptor typeParameterDescriptor,
@NotNull final TypeVariableResolver typeVariableByPsiResolver) {
@NotNull final TypeVariableResolver typeVariableByPsiResolver,
@NotNull final TypeUsage howThisTypeIsUsed
) {
TypeProjection result = javaType.accept(new PsiTypeVisitor<TypeProjection>() {
@Override
@@ -76,18 +79,18 @@ public class JavaTypeTransformer {
@Override
public TypeProjection visitWildcardType(PsiWildcardType wildcardType) {
if (!wildcardType.isBounded()) {
return TypeUtils.makeStarProjection(typeParameterDescriptor);
return SubstitutionUtils.makeStarProjection(typeParameterDescriptor);
}
Variance variance = wildcardType.isExtends() ? Variance.OUT_VARIANCE : Variance.IN_VARIANCE;
PsiType bound = wildcardType.getBound();
assert bound != null;
return new TypeProjection(variance, transformToType(bound, TypeUsage.UPPER_BOUND, typeVariableByPsiResolver));
return new TypeProjection(variance, transformToType(bound, UPPER_BOUND, typeVariableByPsiResolver));
}
@Override
public TypeProjection visitType(PsiType type) {
return new TypeProjection(transformToType(type, TypeUsage.TYPE_ARGUMENT, typeVariableByPsiResolver));
return new TypeProjection(transformToType(type, howThisTypeIsUsed, typeVariableByPsiResolver));
}
});
return result;
@@ -126,22 +129,39 @@ public class JavaTypeTransformer {
if (psiClass instanceof PsiTypeParameter) {
PsiTypeParameter typeParameter = (PsiTypeParameter) psiClass;
PsiTypeParameterListOwner typeParameterListOwner = typeParameter.getOwner();
if (typeParameterListOwner instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) typeParameterListOwner;
if (psiMethod.isConstructor()) {
Set<JetType> supertypesJet = Sets.newHashSet();
for (PsiClassType supertype : typeParameter.getExtendsListTypes()) {
supertypesJet.add(transformToType(supertype, UPPER_BOUND, typeVariableResolver));
}
return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet);
}
}
TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName());
if (howThisTypeIsUsed == TypeUsage.TYPE_ARGUMENT || howThisTypeIsUsed == TypeUsage.UPPER_BOUND) {
// In Java: ArrayList<T>
// In Kotlin: ArrayList<T>, not ArrayList<T?>
// nullability will be taken care of in individual member signatures
return typeParameterDescriptor.getDefaultType();
// In Java: ArrayList<T>
// In Kotlin: ArrayList<T>, not ArrayList<T?>
// nullability will be taken care of in individual member signatures
boolean nullable = !EnumSet.of(TYPE_ARGUMENT, UPPER_BOUND, SUPERTYPE_ARGUMENT).contains(howThisTypeIsUsed);
if (nullable) {
return TypeUtils.makeNullable(typeParameterDescriptor.getDefaultType());
}
else {
return TypeUtils.makeNullable(typeParameterDescriptor.getDefaultType());
return typeParameterDescriptor.getDefaultType();
}
}
else {
// 'L extends List<T>' in Java is a List<T> in Kotlin, not a List<T?>
boolean nullable = !EnumSet.of(SUPERTYPE_ARGUMENT, SUPERTYPE).contains(howThisTypeIsUsed);
JetType jetAnalog = getKotlinAnalog(new FqName(psiClass.getQualifiedName()));
if (jetAnalog != null) {
return jetAnalog;
return TypeUtils.makeNullableAsSpecified(jetAnalog, nullable);
}
final ClassDescriptor classData =
@@ -154,7 +174,7 @@ public class JavaTypeTransformer {
if (classType.isRaw()) {
List<TypeParameterDescriptor> parameters = classData.getTypeConstructor().getParameters();
for (TypeParameterDescriptor parameter : parameters) {
arguments.add(TypeUtils.makeStarProjection(parameter));
arguments.add(SubstitutionUtils.makeStarProjection(parameter));
}
}
else {
@@ -171,13 +191,15 @@ public class JavaTypeTransformer {
PsiType psiArgument = psiArguments[i];
TypeParameterDescriptor typeParameterDescriptor = parameters.get(i);
arguments.add(transformToTypeProjection(psiArgument, typeParameterDescriptor, typeVariableResolver));
TypeUsage howTheProjectionIsUsed = howThisTypeIsUsed == SUPERTYPE ? SUPERTYPE_ARGUMENT : TYPE_ARGUMENT;
arguments.add(transformToTypeProjection(psiArgument, typeParameterDescriptor, typeVariableResolver, howTheProjectionIsUsed));
}
}
return new JetTypeImpl(
Collections.<AnnotationDescriptor>emptyList(),
classData.getTypeConstructor(),
true,
nullable,
arguments,
classData.getMemberScope(arguments));
}
@@ -275,6 +297,7 @@ public class JavaTypeTransformer {
MEMBER_SIGNATURE_COVARIANT,
MEMBER_SIGNATURE_CONTRAVARIANT,
MEMBER_SIGNATURE_INVARIANT,
SUPERTYPE
SUPERTYPE,
SUPERTYPE_ARGUMENT
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JdkNames.java
+26
View File
@@ -0,0 +1,26 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java;
/**
* @author Stepan Koltsov
*/
public class JdkNames {
public static final JvmClassName JL_OBJECT = new JvmClassName("java.lang.Object");
}
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
+2 -2
View File
@@ -41,7 +41,7 @@ import org.jetbrains.jet.plugin.JetMainDetector;
import java.util.*;
import static org.jetbrains.jet.lang.diagnostics.Errors.*;
import static org.jetbrains.jet.lang.resolve.BindingContext.MUST_BE_WRAPPED_IN_A_REF;
import static org.jetbrains.jet.lang.resolve.BindingContext.CAPTURED_IN_CLOSURE;
import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
/**
@@ -599,7 +599,7 @@ public class JetFlowInformationProvider {
!DescriptorUtils.isLocal(variableDescriptor.getContainingDeclaration(), variableDescriptor)) return;
VariableStatus variableStatus = enterData.get(variableDescriptor);
if (instruction instanceof WriteValueInstruction) {
if (trace.get(MUST_BE_WRAPPED_IN_A_REF, variableDescriptor)) return;
if (trace.get(CAPTURED_IN_CLOSURE, variableDescriptor)) return;
JetElement element = ((WriteValueInstruction) instruction).getElement();
if (variableStatus != VariableStatus.READ) {
if (element instanceof JetBinaryExpression && ((JetBinaryExpression) element).getOperationToken() == JetTokens.EQ) {
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java
+2 -1
View File
@@ -97,7 +97,8 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
if (typeConstructor.getParameters().isEmpty()) {
return memberDeclarations;
}
Map<TypeConstructor, TypeProjection> substitutionContext = TypeUtils.buildSubstitutionContext(typeConstructor.getParameters(), typeArguments);
Map<TypeConstructor, TypeProjection> substitutionContext = SubstitutionUtils
.buildSubstitutionContext(typeConstructor.getParameters(), typeArguments);
return new SubstitutingScope(memberDeclarations, TypeSubstitutor.create(substitutionContext));
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java
+3 -2
View File
@@ -21,6 +21,7 @@ import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver;
@@ -47,7 +48,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorImpl i
protected Modality modality;
protected Visibility visibility;
protected final Set<FunctionDescriptor> overriddenFunctions = Sets.newLinkedHashSet();
protected final Set<FunctionDescriptor> overriddenFunctions = Sets.newLinkedHashSet(); // LinkedHashSet is essential here
private final FunctionDescriptor original;
private final Kind kind;
@@ -230,7 +231,7 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorImpl i
);
if (copyOverrides) {
for (FunctionDescriptor overriddenFunction : overriddenFunctions) {
substitutedDescriptor.addOverriddenDescriptor(overriddenFunction.substitute(substitutor));
OverridingUtil.bindOverride(substitutedDescriptor, overriddenFunction.substitute(substitutor));
}
}
return substitutedDescriptor;
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java
+15 -3
View File
@@ -119,18 +119,30 @@ public class FunctionDescriptorUtil {
return parameterScope;
}
public static void initializeFromFunctionType(@NotNull FunctionDescriptorImpl functionDescriptor, @NotNull JetType functionType, @NotNull ReceiverDescriptor expectedThisObject) {
public static void initializeFromFunctionType(@NotNull FunctionDescriptorImpl functionDescriptor, @NotNull JetType functionType, @NotNull ReceiverDescriptor expectedThisObject,
@NotNull Modality modality, @NotNull Visibility visibility) {
assert JetStandardClasses.isFunctionType(functionType);
functionDescriptor.initialize(JetStandardClasses.getReceiverType(functionType),
expectedThisObject,
Collections.<TypeParameterDescriptor>emptyList(),
JetStandardClasses.getValueParameters(functionDescriptor, functionType),
JetStandardClasses.getReturnTypeFromFunctionType(functionType),
Modality.FINAL,
Visibilities.LOCAL);
modality,
visibility);
}
public static <D extends CallableDescriptor> D alphaConvertTypeParameters(D candidate) {
return (D) candidate.substitute(MAKE_TYPE_PARAMETERS_FRESH);
}
public static FunctionDescriptor getInvokeFunction(@NotNull JetType functionType) {
assert JetStandardClasses.isFunctionType(functionType);
ClassifierDescriptor classDescriptorForFunction = functionType.getConstructor().getDeclarationDescriptor();
assert classDescriptorForFunction instanceof ClassDescriptor;
Set<FunctionDescriptor> invokeFunctions = ((ClassDescriptor) classDescriptorForFunction).getMemberScope(functionType.getArguments()).getFunctions("invoke");
assert invokeFunctions.size() == 1;
return invokeFunctions.iterator().next();
}
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java
+17 -5
View File
@@ -33,7 +33,8 @@ import java.util.Set;
* @author abreslav
*/
public class MutableClassDescriptor extends MutableClassDescriptorLite {
private final Set<CallableMemberDescriptor> callableMembers = Sets.newHashSet();
private final Set<CallableMemberDescriptor> declaredCallableMembers = Sets.newHashSet();
private final Set<CallableMemberDescriptor> allCallableMembers = Sets.newHashSet(); // includes fake overrides
private final Set<PropertyDescriptor> properties = Sets.newHashSet();
private final Set<SimpleFunctionDescriptor> functions = Sets.newHashSet();
@@ -104,7 +105,10 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite {
public void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor) {
super.addPropertyDescriptor(propertyDescriptor);
properties.add(propertyDescriptor);
callableMembers.add(propertyDescriptor);
if (propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
declaredCallableMembers.add(propertyDescriptor);
}
allCallableMembers.add(propertyDescriptor);
scopeForMemberResolution.addPropertyDescriptor(propertyDescriptor);
}
@@ -112,7 +116,10 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite {
public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) {
super.addFunctionDescriptor(functionDescriptor);
functions.add(functionDescriptor);
callableMembers.add(functionDescriptor);
if (functionDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
declaredCallableMembers.add(functionDescriptor);
}
allCallableMembers.add(functionDescriptor);
scopeForMemberResolution.addFunctionDescriptor(functionDescriptor);
}
@@ -127,8 +134,13 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite {
}
@NotNull
public Set<CallableMemberDescriptor> getCallableMembers() {
return callableMembers;
public Set<CallableMemberDescriptor> getDeclaredCallableMembers() {
return declaredCallableMembers;
}
@NotNull
public Set<CallableMemberDescriptor> getAllCallableMembers() {
return allCallableMembers;
}
@Override
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java
+2 -2
View File
@@ -127,7 +127,7 @@ public class MutableClassDescriptorLite extends MutableDeclarationDescriptor imp
}
}
public WritableScope getScopeForMemberLookupAsWritableScope() {
private WritableScope getScopeForMemberLookupAsWritableScope() {
// hack
return (WritableScope) scopeForMemberLookup;
}
@@ -139,7 +139,7 @@ public class MutableClassDescriptorLite extends MutableDeclarationDescriptor imp
if (typeArguments.isEmpty()) return scopeForMemberLookup;
List<TypeParameterDescriptor> typeParameters = getTypeConstructor().getParameters();
Map<TypeConstructor, TypeProjection> substitutionContext = TypeUtils.buildSubstitutionContext(typeParameters, typeArguments);
Map<TypeConstructor, TypeProjection> substitutionContext = SubstitutionUtils.buildSubstitutionContext(typeParameters, typeArguments);
return new SubstitutingScope(scopeForMemberLookup, TypeSubstitutor.create(substitutionContext));
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
+3 -2
View File
@@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver;
@@ -42,7 +43,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab
private Visibility visibility;
private final boolean isVar;
private final boolean isObject;
private final Set<PropertyDescriptor> overriddenProperties = Sets.newLinkedHashSet();
private final Set<PropertyDescriptor> overriddenProperties = Sets.newLinkedHashSet(); // LinkedHashSet is essential here
private final PropertyDescriptor original;
private final Kind kind;
@@ -268,7 +269,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab
if (copyOverrides) {
for (PropertyDescriptor propertyDescriptor : overriddenProperties) {
substitutedDescriptor.addOverriddenDescriptor(propertyDescriptor.substitute(substitutor));
OverridingUtil.bindOverride(substitutedDescriptor, propertyDescriptor.substitute(substitutor));
}
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java
+27 -1
View File
@@ -21,6 +21,8 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
import org.jetbrains.jet.lang.types.JetType;
import java.util.Set;
/**
* @author abreslav
*/
@@ -31,8 +33,22 @@ public interface ValueParameterDescriptor extends VariableDescriptor, Annotated
* @return the parameter index
*/
int getIndex();
/**
* The font-end relies on this property when resolving function calls
*
* @return {@code true} iff the parameter has a default value, i.e. declares it or inherits
* by overriding a parameter in an overridden function.
*/
boolean hasDefaultValue();
boolean isRef();
/**
* The back-end should relies on this property when generating function signatures
*
* @return {@code true} iff the parameter declares a default value, i.e. explicitly specifies it in the function header
*/
boolean declaresDefaultValue();
@Nullable JetType getVarargElementType();
@Override
@@ -46,4 +62,14 @@ public interface ValueParameterDescriptor extends VariableDescriptor, Annotated
@NotNull
ValueParameterDescriptor copy(DeclarationDescriptor newOwner);
/**
* Parameter p1 overrides p2 iff
* a) their respective owners (function declarations) f1 override f2
* b) p1 and p2 have the same indices in the owners' parameter lists
*/
@NotNull
@Override
Set<? extends ValueParameterDescriptor> getOverriddenDescriptors();
void addOverriddenDescriptor(@NotNull ValueParameterDescriptor overridden);
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java
+47 -7
View File
@@ -17,24 +17,33 @@
package org.jetbrains.jet.lang.descriptors;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import java.util.Collections;
import java.util.List;
import java.util.Set;
/**
* @author abreslav
*/
public class ValueParameterDescriptorImpl extends VariableDescriptorImpl implements MutableValueParameterDescriptor {
private final boolean hasDefaultValue;
private Boolean hasDefaultValue;
private final boolean declaresDefaultValue;
private final JetType varargElementType;
private final boolean isVar;
private final int index;
private final ValueParameterDescriptor original;
private final Set<ValueParameterDescriptor> overriddenDescriptors = Sets.newLinkedHashSet(); // Linked is essential
private boolean overriddenDescriptorsLocked = false;
private final Set<? extends ValueParameterDescriptor> readOnlyOverriddenDescriptors = Collections.unmodifiableSet(overriddenDescriptors);
public ValueParameterDescriptorImpl(
@NotNull DeclarationDescriptor containingDeclaration,
int index,
@@ -42,12 +51,12 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
@NotNull String name,
boolean isVar,
@NotNull JetType outType,
boolean hasDefaultValue,
boolean declaresDefaultValue,
@Nullable JetType varargElementType) {
super(containingDeclaration, annotations, name, outType);
this.original = this;
this.index = index;
this.hasDefaultValue = hasDefaultValue;
this.declaresDefaultValue = declaresDefaultValue;
this.varargElementType = varargElementType;
this.isVar = isVar;
}
@@ -59,11 +68,11 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
boolean isVar,
@NotNull JetType outType,
@Nullable JetType varargElementType
) {
) {
super(containingDeclaration, annotations, original.getName(), outType);
this.original = original;
this.index = original.getIndex();
this.hasDefaultValue = original.hasDefaultValue();
this.declaresDefaultValue = original.declaresDefaultValue();
this.varargElementType = varargElementType;
this.isVar = isVar;
}
@@ -80,12 +89,30 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
@Override
public boolean hasDefaultValue() {
computeDefaultValuePresence();
return hasDefaultValue;
}
@Override
public boolean isRef() {
throw new UnsupportedOperationException(); // TODO
public boolean declaresDefaultValue() {
return declaresDefaultValue && ((CallableMemberDescriptor) getContainingDeclaration()).getKind().isReal();
}
private void computeDefaultValuePresence() {
if (hasDefaultValue != null) return;
overriddenDescriptorsLocked = true;
if (declaresDefaultValue) {
hasDefaultValue = true;
}
else {
for (ValueParameterDescriptor descriptor : overriddenDescriptors) {
if (descriptor.hasDefaultValue()) {
hasDefaultValue = true;
return;
}
}
hasDefaultValue = false;
}
}
@Nullable
@@ -131,4 +158,17 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
public Visibility getVisibility() {
return Visibilities.LOCAL;
}
@NotNull
@Override
public Set<? extends ValueParameterDescriptor> getOverriddenDescriptors() {
return readOnlyOverriddenDescriptors;
}
@Override
public void addOverriddenDescriptor(@NotNull ValueParameterDescriptor overridden) {
assert !overriddenDescriptorsLocked : "Adding more overridden descriptors is not allowed at this point: " +
"the presence of the default value has already been calculated";
overriddenDescriptors.add(overridden);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java
-58
View File
@@ -1,58 +0,0 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import java.util.Collections;
/**
* @author abreslav
*/
public class VariableAsFunctionDescriptor extends FunctionDescriptorImpl {
public static VariableAsFunctionDescriptor create(@NotNull VariableDescriptor variableDescriptor) {
JetType outType = variableDescriptor.getType();
assert outType != null;
VariableAsFunctionDescriptor result = new VariableAsFunctionDescriptor(variableDescriptor);
FunctionDescriptorUtil.initializeFromFunctionType(result, outType, variableDescriptor.getExpectedThisObject());
return result;
}
private final VariableDescriptor variableDescriptor;
private VariableAsFunctionDescriptor(VariableDescriptor variableDescriptor) {
super(variableDescriptor.getContainingDeclaration(), Collections.<AnnotationDescriptor>emptyList(), variableDescriptor.getName(), Kind.DECLARATION);
this.variableDescriptor = variableDescriptor;
}
public VariableDescriptor getVariableDescriptor() {
return variableDescriptor;
}
@NotNull
@Override
public VariableAsFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract, Kind kind, boolean copyOverrides) {
throw new UnsupportedOperationException("Should not be copied for overriding");
}
@Override
protected FunctionDescriptorImpl createSubstitutedCopy(DeclarationDescriptor newOwner, boolean preserveOriginal, Kind kind) {
throw new IllegalStateException();
}
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
+12 -7
View File
@@ -51,7 +51,7 @@ public interface Errors {
//Elements with "INVISIBLE_REFERENCE" error are marked as unresolved, unlike elements with "INVISIBLE_MEMBER" error
DiagnosticFactory2<JetSimpleNameExpression, DeclarationDescriptor, DeclarationDescriptor> INVISIBLE_REFERENCE =
DiagnosticFactory2.create(ERROR);
DiagnosticFactory2<PsiElement, DeclarationDescriptor, DeclarationDescriptor> INVISIBLE_MEMBER = DiagnosticFactory2.create(ERROR);
DiagnosticFactory2<PsiElement, DeclarationDescriptor, DeclarationDescriptor> INVISIBLE_MEMBER = DiagnosticFactory2.create(ERROR, PositioningStrategies.CALL_ELEMENT);
RedeclarationDiagnosticFactory REDECLARATION = new RedeclarationDiagnosticFactory(ERROR);
RedeclarationDiagnosticFactory NAME_SHADOWING = new RedeclarationDiagnosticFactory(WARNING);
@@ -247,12 +247,12 @@ public interface Errors {
public List<TextRange> mark(@NotNull JetDeclarationWithBody element) {
JetExpression bodyExpression = element.getBodyExpression();
if (!(bodyExpression instanceof JetBlockExpression)) {
return Collections.emptyList();
return markElement(element);
}
JetBlockExpression blockExpression = (JetBlockExpression)bodyExpression;
TextRange lastBracketRange = blockExpression.getLastBracketRange();
if (lastBracketRange == null) {
return Collections.emptyList();
return markElement(element);
}
return markRange(lastBracketRange);
}
@@ -288,7 +288,6 @@ public interface Errors {
@NotNull
@Override
public List<TextRange> mark(@NotNull JetWhenExpression element) {
if (hasSyntaxError(element)) return Collections.emptyList();
return markElement(element.getWhenKeywordElement());
}
});
@@ -380,6 +379,12 @@ public interface Errors {
DiagnosticFactory2<PsiElement, JetClassOrObject, CallableMemberDescriptor> MANY_IMPL_MEMBER_NOT_IMPLEMENTED =
DiagnosticFactory2.create(ERROR);
SimpleDiagnosticFactory<JetParameter> DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE = SimpleDiagnosticFactory.create(ERROR, PositioningStrategies.PARAMETER_DEFAULT_VALUE);
DiagnosticFactory1<JetParameter, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES = DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER);
DiagnosticFactory1<JetClassOrObject, ValueParameterDescriptor> MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE = DiagnosticFactory1.create(ERROR, PositioningStrategies.POSITION_NAME_IDENTIFIER);
DiagnosticFactory2<JetParameter, ClassDescriptor, ValueParameterDescriptor> PARAMETER_NAME_CHANGED_ON_OVERRIDE = DiagnosticFactory2.create(WARNING, PositioningStrategies.POSITION_NAME_IDENTIFIER);
DiagnosticFactory2<JetClassOrObject, Collection<? extends CallableMemberDescriptor>, Integer> DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES = DiagnosticFactory2.create(WARNING, PositioningStrategies.POSITION_NAME_IDENTIFIER);
DiagnosticFactory2<JetDeclaration, CallableMemberDescriptor, String> CONFLICTING_OVERLOADS =
DiagnosticFactory2.create(ERROR, new PositioningStrategy<JetDeclaration>() {
@NotNull
@@ -397,7 +402,7 @@ public interface Errors {
JetClass klass = (JetClass)jetDeclaration;
PsiElement nameAsDeclaration = klass.getNameIdentifier();
if (nameAsDeclaration == null) {
return markRange(klass.getTextRange());
return markElement(klass);
}
PsiElement primaryConstructorParameterList = klass.getPrimaryConstructorParameterList();
if (primaryConstructorParameterList == null) {
@@ -410,7 +415,7 @@ public interface Errors {
}
else {
// safe way
return markRange(jetDeclaration.getTextRange());
return markElement(jetDeclaration);
}
}
});
@@ -443,7 +448,7 @@ public interface Errors {
class Initializer {
static {
for (Field field : Errors.class.getFields()) {
if ((field.getModifiers() & Modifier.STATIC) != 0) {
if (Modifier.isStatic(field.getModifiers())) {
try {
Object value = field.get(null);
if (value instanceof AbstractDiagnosticFactory) {
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java
+28 -11
View File
@@ -28,7 +28,6 @@ import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lexer.JetKeywordToken;
import org.jetbrains.jet.lexer.JetTokens;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@@ -60,10 +59,9 @@ public class PositioningStrategies {
returnTypeRef = accessor.getReturnTypeReference();
nameNode = accessor.getNamePlaceholder().getNode();
}
if (returnTypeRef != null) return Collections.singletonList(returnTypeRef.getTextRange());
if (nameNode != null) return Collections.singletonList(nameNode.getTextRange());
return super.mark(declaration);
if (returnTypeRef != null) return markElement(returnTypeRef);
if (nameNode != null) return markNode(nameNode);
return markElement(declaration);
}
private ASTNode getNameNode(JetNamedDeclaration function) {
@@ -76,14 +74,11 @@ public class PositioningStrategies {
@NotNull
@Override
public List<TextRange> mark(@NotNull PsiNameIdentifierOwner element) {
if (element.getLastChild() instanceof PsiErrorElement) {
return Collections.emptyList();
}
PsiElement nameIdentifier = element.getNameIdentifier();
if (nameIdentifier != null) {
return markElement(nameIdentifier);
}
return Collections.emptyList();
return markElement(element);
}
};
@@ -101,9 +96,9 @@ public class PositioningStrategies {
assert modifierList != null;
ASTNode node = modifierList.getModifierNode(token);
assert node != null;
return Collections.singletonList(node.getTextRange());
return markNode(node);
}
return Collections.emptyList();
return markElement(modifierListOwner);
}
};
}
@@ -144,4 +139,26 @@ public class PositioningStrategies {
return markNode(element.getProjectionNode());
}
};
public static PositioningStrategy<JetParameter> PARAMETER_DEFAULT_VALUE = new PositioningStrategy<JetParameter>() {
@NotNull
@Override
public List<TextRange> mark(@NotNull JetParameter element) {
return markNode(element.getDefaultValue().getNode());
}
};
public static PositioningStrategy<PsiElement> CALL_ELEMENT = new PositioningStrategy<PsiElement>() {
@NotNull
@Override
public List<TextRange> mark(@NotNull PsiElement callElement) {
if (callElement instanceof JetCallElement) {
JetExpression calleeExpression = ((JetCallElement) callElement).getCalleeExpression();
if (calleeExpression != null) {
return markElement(calleeExpression);
}
}
return markElement(callElement);
}
};
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java
+4 -1
View File
@@ -34,7 +34,10 @@ public class UnresolvedReferenceDiagnosticFactory extends DiagnosticFactory1<Jet
@Override
public List<TextRange> mark(@NotNull JetReferenceExpression element) {
if (element instanceof JetArrayAccessExpression) {
return ((JetArrayAccessExpression) element).getBracketRanges();
List<TextRange> ranges = ((JetArrayAccessExpression) element).getBracketRanges();
if (!ranges.isEmpty()) {
return ranges;
}
}
return Collections.singletonList(element.getTextRange());
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java
+35
View File
@@ -17,7 +17,9 @@
package org.jetbrains.jet.lang.diagnostics.rendering;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.diagnostics.AbstractDiagnosticFactory;
import org.jetbrains.jet.lang.diagnostics.Diagnostic;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
import org.jetbrains.jet.lang.psi.JetTypeConstraint;
@@ -25,6 +27,8 @@ import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lexer.JetKeywordToken;
import org.jetbrains.jet.resolve.DescriptorRenderer;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Collection;
import java.util.Iterator;
@@ -385,7 +389,38 @@ public class DefaultErrorMessages {
MAP.put(NOT_AN_ANNOTATION_CLASS, "''{0}'' is not an annotation class", TO_STRING);
MAP.put(DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE, "An overriding function is not allowed to specify default values for its parameters");
String multipleDefaultsMessage = "More than one overridden descriptor declares a default value for ''{0}''. " +
"As the compiler can not make sure these values agree, this is not allowed.";
MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES, multipleDefaultsMessage, TO_STRING);
MAP.put(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE, multipleDefaultsMessage, TO_STRING);
MAP.put(PARAMETER_NAME_CHANGED_ON_OVERRIDE, "The corresponding parameter in the supertype ''{0}'' is named ''{1}''. " +
"This may cause problems when calling this function with named arguments.", NAME, NAME);
MAP.put(DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES,
"Names of the parameter #{1} conflict in the following members of supertypes: ''{0}''" +
"This may cause problems when calling this function with named arguments.", commaSeparated(TO_STRING), TO_STRING);
MAP.setImmutable();
for (Field field : Errors.class.getFields()) {
if (Modifier.isStatic(field.getModifiers())) {
try {
Object fieldValue = field.get(null);
if (fieldValue instanceof AbstractDiagnosticFactory) {
if (MAP.get((AbstractDiagnosticFactory) fieldValue) == null) {
throw new IllegalStateException("No default diagnostic renderer is provided for " + ((AbstractDiagnosticFactory)fieldValue).getName());
}
}
}
catch (IllegalAccessException e) {
throw new IllegalStateException(e);
}
}
}
}
private DefaultErrorMessages() {
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java
+19
View File
@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.resolve.DescriptorRenderer;
import java.util.Collection;
import java.util.Iterator;
/**
* @author svtk
@@ -98,6 +99,24 @@ public class Renderers {
}
};
public static <T> Renderer<Collection<? extends T>> commaSeparated(final Renderer<T> itemRenderer) {
return new Renderer<Collection<? extends T>>() {
@NotNull
@Override
public String render(@NotNull Collection<? extends T> object) {
StringBuilder result = new StringBuilder();
for (Iterator<? extends T> iterator = object.iterator(); iterator.hasNext(); ) {
T next = iterator.next();
result.append(itemRenderer.render(next));
if (iterator.hasNext()) {
result.append(", ");
}
}
return result.toString();
}
};
}
private Renderers() {
}
}
compiler/frontend/src/org/jetbrains/jet/lang/psi/Call.java
+3
View File
@@ -36,6 +36,9 @@ public interface Call {
@NotNull
ReceiverDescriptor getExplicitReceiver();
@NotNull
ReceiverDescriptor getThisObject();
@Nullable
JetExpression getCalleeExpression();
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassOrObject.java
+2 -1
View File
@@ -17,6 +17,7 @@
package org.jetbrains.jet.lang.psi;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiNameIdentifierOwner;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -25,7 +26,7 @@ import java.util.List;
/**
* @author max
*/
public interface JetClassOrObject extends PsiElement {
public interface JetClassOrObject extends PsiElement, PsiNameIdentifierOwner {
List<JetDeclaration> getDeclarations();
@Nullable
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java
+6
View File
@@ -16,6 +16,7 @@
package org.jetbrains.jet.lang.psi;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.impl.CheckUtil;
import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
@@ -308,4 +309,9 @@ public class JetPsiUtil {
return "Unit".equals(typeReference.getText());
}
public static boolean isSafeCall(@NotNull Call call) {
ASTNode callOperationNode = call.getCallOperationNode();
return callOperationNode != null && callOperationNode.getElementType() == JetTokens.SAFE_ACCESS;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
+2 -1
View File
@@ -61,6 +61,7 @@ public interface BindingContext {
WritableSlice<JetExpression, JetType> AUTOCAST = Slices.createSimpleSlice();
/** A scope where type of expression has been resolved */
WritableSlice<JetTypeReference, JetScope> TYPE_RESOLUTION_SCOPE = Slices.createSimpleSlice();
WritableSlice<JetExpression, JetScope> RESOLUTION_SCOPE = Slices.createSimpleSlice();
/** Collected during analyze, used in IDE in auto-cast completion */
@@ -75,7 +76,7 @@ public interface BindingContext {
WritableSlice<JetElement, Boolean> STATEMENT = Slices.createRemovableSetSlice();
WritableSlice<CallableMemberDescriptor, Boolean> DELEGATED = Slices.createRemovableSetSlice();
WritableSlice<VariableDescriptor, Boolean> MUST_BE_WRAPPED_IN_A_REF = Slices.createSimpleSetSlice();
WritableSlice<VariableDescriptor, Boolean> CAPTURED_IN_CLOSURE = Slices.createSimpleSetSlice();
// enum DeferredTypeKey {DEFERRED_TYPE_KEY}
// WritableSlice<DeferredTypeKey, Collection<DeferredType>> DEFERRED_TYPES = Slices.createSimpleSlice();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java
+26 -23
View File
@@ -20,14 +20,10 @@ import com.google.common.collect.Lists;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableAsFunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
import org.jetbrains.jet.lang.resolve.calls.VariableAsFunctionResolvedCall;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
import org.jetbrains.jet.util.slicedmap.Slices;
@@ -53,12 +49,12 @@ public class BindingContextUtils {
throw new IllegalStateException("non-declaration descriptors should be filtered out earler: " + callable);
}
}
if (declarationDescriptor instanceof VariableAsFunctionDescriptor) {
VariableAsFunctionDescriptor descriptor = (VariableAsFunctionDescriptor) declarationDescriptor;
if (descriptor.getOriginal() != descriptor) {
throw new IllegalStateException("original should be resolved earlier: " + descriptor);
}
}
//if (declarationDescriptor instanceof VariableAsFunctionDescriptor) {
// VariableAsFunctionDescriptor descriptor = (VariableAsFunctionDescriptor) declarationDescriptor;
// if (descriptor.getOriginal() != descriptor) {
// throw new IllegalStateException("original should be resolved earlier: " + descriptor);
// }
//}
return declarationDescriptor.getOriginal();
}
};
@@ -68,7 +64,7 @@ public class BindingContextUtils {
@Nullable
public static PsiElement resolveToDeclarationPsiElement(@NotNull BindingContext bindingContext, @Nullable JetReferenceExpression referenceExpression) {
DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, referenceExpression);
DeclarationDescriptor declarationDescriptor = referenceToDescriptor(bindingContext, referenceExpression);
if (declarationDescriptor == null) {
return bindingContext.get(BindingContext.LABEL_TARGET, referenceExpression);
}
@@ -88,7 +84,7 @@ public class BindingContextUtils {
@NotNull
public static List<PsiElement> resolveToDeclarationPsiElements(@NotNull BindingContext bindingContext, @Nullable JetReferenceExpression referenceExpression) {
DeclarationDescriptor declarationDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, referenceExpression);
DeclarationDescriptor declarationDescriptor = referenceToDescriptor(bindingContext, referenceExpression);
if (declarationDescriptor == null) {
return Lists.newArrayList(bindingContext.get(BindingContext.LABEL_TARGET, referenceExpression));
}
@@ -114,7 +110,7 @@ public class BindingContextUtils {
descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element);
}
else if (element instanceof JetSimpleNameExpression) {
descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) element);
descriptor = referenceToDescriptor(bindingContext, (JetSimpleNameExpression) element);
}
else if (element instanceof JetQualifiedExpression) {
descriptor = extractVariableDescriptorIfAny(bindingContext, ((JetQualifiedExpression) element).getSelectorExpression(), onlyReference);
@@ -122,12 +118,19 @@ public class BindingContextUtils {
if (descriptor instanceof VariableDescriptor) {
return (VariableDescriptor) descriptor;
}
if (descriptor instanceof VariableAsFunctionDescriptor) {
return ((VariableAsFunctionDescriptor) descriptor).getVariableDescriptor();
}
return null;
}
@Nullable
public static DeclarationDescriptor referenceToDescriptor(@NotNull BindingContext bindingContext, @Nullable JetReferenceExpression element) {
DeclarationDescriptor descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, element);
ResolvedCall<? extends CallableDescriptor> resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, element);
if (resolvedCall instanceof VariableAsFunctionResolvedCall) {
descriptor = ((VariableAsFunctionResolvedCall) resolvedCall).getVariableCall().getResultingDescriptor();
}
return descriptor;
}
// TODO these helper methods are added as a workaround to some compiler bugs in Kotlin...
// NOTE this is used by KDoc
@@ -178,7 +181,7 @@ public class BindingContextUtils {
// TODO evil code
throw new IllegalStateException(
"cannot find declaration: fake descriptor" +
" has more then one overriden descriptor: " + callable);
" has more then one overridden descriptor: " + callable);
}
return callableDescriptorToDeclaration(context, overriddenDescriptors.iterator().next());
@@ -190,9 +193,9 @@ public class BindingContextUtils {
private static List<PsiElement> callableDescriptorToDeclarations(@NotNull BindingContext context, @NotNull CallableMemberDescriptor callable) {
if (callable.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
List<PsiElement> r = new ArrayList<PsiElement>();
Set<? extends CallableMemberDescriptor> overridenDescriptors = callable.getOverriddenDescriptors();
for (CallableMemberDescriptor overriden : overridenDescriptors) {
r.addAll(callableDescriptorToDeclarations(context, overriden));
Set<? extends CallableMemberDescriptor> overriddenDescriptors = callable.getOverriddenDescriptors();
for (CallableMemberDescriptor overridden : overriddenDescriptors) {
r.addAll(callableDescriptorToDeclarations(context, overridden));
}
return r;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ChainedTemporaryBindingTrace.java
+37
View File
@@ -0,0 +1,37 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve;
/**
* @author svtk
*/
public class ChainedTemporaryBindingTrace extends TemporaryBindingTrace {
public static ChainedTemporaryBindingTrace create(TemporaryBindingTrace trace) {
return new ChainedTemporaryBindingTrace(trace);
}
private ChainedTemporaryBindingTrace(TemporaryBindingTrace trace) {
super(trace);
}
@Override
public void commit() {
super.commit();
((TemporaryBindingTrace) trace).commit();
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java
+2 -4
View File
@@ -21,10 +21,8 @@ import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.util.Pair;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.inject.Inject;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.psi.*;
@@ -34,6 +32,7 @@ import org.jetbrains.jet.lexer.JetKeywordToken;
import org.jetbrains.jet.lexer.JetToken;
import org.jetbrains.jet.lexer.JetTokens;
import javax.inject.Inject;
import java.util.Collection;
import java.util.List;
import java.util.Map;
@@ -132,8 +131,7 @@ public class DeclarationsChecker {
}
private void checkOpenMembers(MutableClassDescriptor classDescriptor) {
for (CallableMemberDescriptor memberDescriptor : classDescriptor.getCallableMembers()) {
for (CallableMemberDescriptor memberDescriptor : classDescriptor.getDeclaredCallableMembers()) {
JetNamedDeclaration member = (JetNamedDeclaration) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), memberDescriptor);
if (member != null && classDescriptor.getModality() == Modality.FINAL && member.hasModifier(JetTokens.OPEN_KEYWORD)) {
trace.report(NON_FINAL_MEMBER_IN_FINAL_CLASS.on(member));
compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java
+34 -10
View File
@@ -332,16 +332,33 @@ public class DescriptorResolver {
return typeParameterDescriptor;
}
final class UpperBoundCheckerTask {
JetTypeReference upperBound;
JetType upperBoundType;
boolean isClassObjectConstraint;
private UpperBoundCheckerTask(JetTypeReference upperBound, JetType upperBoundType, boolean classObjectConstraint) {
this.upperBound = upperBound;
this.upperBoundType = upperBoundType;
isClassObjectConstraint = classObjectConstraint;
}
}
public void resolveGenericBounds(@NotNull JetTypeParameterListOwner declaration, JetScope scope, List<TypeParameterDescriptor> parameters, BindingTrace trace) {
List<UpperBoundCheckerTask> deferredUpperBoundCheckerTasks = Lists.newArrayList();
List<JetTypeParameter> typeParameters = declaration.getTypeParameters();
Map<String, TypeParameterDescriptor> parameterByName = Maps.newHashMap();
for (int i = 0, typeParametersSize = typeParameters.size(); i < typeParametersSize; i++) {
for (int i = 0; i < typeParameters.size(); i++) {
JetTypeParameter jetTypeParameter = typeParameters.get(i);
TypeParameterDescriptor typeParameterDescriptor = parameters.get(i);
parameterByName.put(typeParameterDescriptor.getName(), typeParameterDescriptor);
JetTypeReference extendsBound = jetTypeParameter.getExtendsBound();
if (extendsBound != null) {
typeParameterDescriptor.addUpperBound(resolveAndCheckUpperBoundType(extendsBound, scope, false, trace));
JetType type = typeResolver.resolveType(scope, extendsBound, trace, false);
typeParameterDescriptor.addUpperBound(type);
deferredUpperBoundCheckerTasks.add(new UpperBoundCheckerTask(extendsBound, type, false));
}
}
for (JetTypeConstraint constraint : declaration.getTypeConstaints()) {
@@ -355,7 +372,12 @@ public class DescriptorResolver {
}
TypeParameterDescriptor typeParameterDescriptor = parameterByName.get(referencedName);
JetTypeReference boundTypeReference = constraint.getBoundTypeReference();
JetType bound = boundTypeReference != null ? resolveAndCheckUpperBoundType(boundTypeReference, scope, constraint.isClassObjectContraint(), trace) : null;
JetType bound = null;
if (boundTypeReference != null) {
bound = typeResolver.resolveType(scope, boundTypeReference, trace, false);
deferredUpperBoundCheckerTasks.add(new UpperBoundCheckerTask(boundTypeReference, bound, constraint.isClassObjectContraint()));
}
if (typeParameterDescriptor == null) {
// To tell the user that we look only for locally defined type parameters
ClassifierDescriptor classifier = scope.getClassifier(referencedName);
@@ -400,19 +422,21 @@ public class DescriptorResolver {
}
}
}
for (UpperBoundCheckerTask checkerTask : deferredUpperBoundCheckerTasks) {
checkUpperBoundType(checkerTask.upperBound, checkerTask.upperBoundType, checkerTask.isClassObjectConstraint, trace);
}
}
private JetType resolveAndCheckUpperBoundType(@NotNull JetTypeReference upperBound, @NotNull JetScope scope, boolean classObjectConstaint, BindingTrace trace) {
JetType jetType = typeResolver.resolveType(scope, upperBound, trace, false);
if (!TypeUtils.canHaveSubtypes(JetTypeChecker.INSTANCE, jetType)) {
if (classObjectConstaint) {
trace.report(FINAL_CLASS_OBJECT_UPPER_BOUND.on(upperBound, jetType));
private static void checkUpperBoundType(JetTypeReference upperBound, JetType upperBoundType, boolean isClassObjectConstraint, BindingTrace trace) {
if (!TypeUtils.canHaveSubtypes(JetTypeChecker.INSTANCE, upperBoundType)) {
if (isClassObjectConstraint) {
trace.report(FINAL_CLASS_OBJECT_UPPER_BOUND.on(upperBound, upperBoundType));
}
else {
trace.report(FINAL_UPPER_BOUND.on(upperBound, jetType));
trace.report(FINAL_UPPER_BOUND.on(upperBound, upperBoundType));
}
}
return jetType;
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportPath.java
+5
View File
@@ -45,6 +45,11 @@ public final class ImportPath {
return fqName.getFqName() + (isAllUnder ? ".*" : "");
}
@Override
public String toString() {
return getPathStr();
}
@NotNull
public FqName fqnPart() {
return fqName;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java
+1 -1
View File
@@ -163,7 +163,7 @@ public class OverloadResolver {
) {
MultiMap<String, CallableMemberDescriptor> functionsByName = MultiMap.create();
for (CallableMemberDescriptor function : classDescriptor.getCallableMembers()) {
for (CallableMemberDescriptor function : classDescriptor.getDeclaredCallableMembers()) {
functionsByName.putValue(function.getName(), function);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
+90 -26
View File
@@ -16,7 +16,10 @@
package org.jetbrains.jet.lang.resolve;
import com.google.common.collect.*;
import com.google.common.collect.LinkedHashMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.util.containers.LinkedMultiMap;
@@ -36,7 +39,6 @@ import javax.inject.Inject;
import java.util.*;
import static org.jetbrains.jet.lang.diagnostics.Errors.*;
import static org.jetbrains.jet.lang.resolve.BindingContext.DECLARATION_TO_DESCRIPTOR;
import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED;
/**
@@ -81,6 +83,7 @@ public class OverrideResolver {
checkVisibility();
checkOverrides(invisibleOverriddenDescriptors);
checkParameterOverridesForAllClasses();
}
/**
@@ -120,7 +123,7 @@ public class OverrideResolver {
MultiMap<String, CallableMemberDescriptor> functionsFromSupertypesByName = groupDescriptorsByName(functionsFromSupertypes);
MultiMap<String, CallableMemberDescriptor> functionsFromCurrentByName = groupDescriptorsByName(classDescriptor.getCallableMembers());
MultiMap<String, CallableMemberDescriptor> functionsFromCurrentByName = groupDescriptorsByName(classDescriptor.getDeclaredCallableMembers());
Set<String> functionNames = new LinkedHashSet<String>();
functionNames.addAll(functionsFromSupertypesByName.keySet());
@@ -135,10 +138,10 @@ public class OverrideResolver {
@Override
public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
if (fakeOverride instanceof PropertyDescriptor) {
classDescriptor.getScopeForMemberLookupAsWritableScope().addPropertyDescriptor((PropertyDescriptor) fakeOverride);
classDescriptor.addPropertyDescriptor((PropertyDescriptor) fakeOverride);
}
else if (fakeOverride instanceof SimpleFunctionDescriptor) {
classDescriptor.getScopeForMemberLookupAsWritableScope().addFunctionDescriptor((SimpleFunctionDescriptor) fakeOverride);
classDescriptor.addFunctionDescriptor((SimpleFunctionDescriptor) fakeOverride);
}
else {
throw new IllegalStateException(fakeOverride.getClass().getName());
@@ -176,7 +179,7 @@ public class OverrideResolver {
for (CallableMemberDescriptor functionFromCurrent : functionsFromCurrent) {
OverridingUtil.OverrideCompatibilityInfo.Result result = OverridingUtil.isOverridableBy(functionFromSupertype, functionFromCurrent).getResult();
if (result == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) {
functionFromCurrent.addOverriddenDescriptor(functionFromSupertype);
OverridingUtil.bindOverride(functionFromCurrent, functionFromSupertype);
overrides = true;
}
else if (result == OverridingUtil.OverrideCompatibilityInfo.Result.CONFLICT) {
@@ -186,14 +189,14 @@ public class OverrideResolver {
for (CallableMemberDescriptor fakeOverride : fakeOverrideList) {
if (OverridingUtil.isOverridableBy(functionFromSupertype, fakeOverride).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) {
fakeOverride.addOverriddenDescriptor(functionFromSupertype);
OverridingUtil.bindOverride(fakeOverride, functionFromSupertype);
overrides = true;
}
}
if (!overrides) {
CallableMemberDescriptor fakeOverride = functionFromSupertype.copy(current, false, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false);
fakeOverride.addOverriddenDescriptor(functionFromSupertype);
OverridingUtil.bindOverride(fakeOverride, functionFromSupertype);
fakeOverrideList.add(fakeOverride);
if (fakeOverrides != null) {
fakeOverrides.add(fakeOverride);
@@ -203,7 +206,6 @@ public class OverrideResolver {
}
}
private static <T extends DeclarationDescriptor> MultiMap<String, T> groupDescriptorsByName(Collection<T> properties) {
MultiMap<String, T> r = new LinkedMultiMap<String, T>();
for (T property : properties) {
@@ -246,7 +248,7 @@ public class OverrideResolver {
if (topDownAnalysisParameters.isAnalyzingBootstrapLibrary()) return;
// Check overrides for internal consistency
for (CallableMemberDescriptor member : classDescriptor.getCallableMembers()) {
for (CallableMemberDescriptor member : classDescriptor.getDeclaredCallableMembers()) {
checkOverrideForMember(member, invisibleOverriddenDescriptors);
}
@@ -258,10 +260,10 @@ public class OverrideResolver {
PsiElement nameIdentifier = null;
if (klass instanceof JetClass) {
nameIdentifier = ((JetClass) klass).getNameIdentifier();
nameIdentifier = klass.getNameIdentifier();
}
else if (klass instanceof JetObjectDeclaration) {
nameIdentifier = ((JetObjectDeclaration) klass).getNameIdentifier();
nameIdentifier = klass.getNameIdentifier();
if (nameIdentifier == null) {
nameIdentifier = ((JetObjectDeclaration) klass).getObjectKeyword();
}
@@ -285,24 +287,16 @@ public class OverrideResolver {
}
public static void collectMissingImplementations(MutableClassDescriptor classDescriptor, Set<CallableMemberDescriptor> abstractNoImpl, Set<CallableMemberDescriptor> manyImpl) {
for (DeclarationDescriptor descriptor : classDescriptor.getScopeForMemberLookup().getAllDescriptors()) {
if (descriptor instanceof CallableMemberDescriptor) {
collectMissingImplementations((CallableMemberDescriptor) descriptor, abstractNoImpl, manyImpl);
}
for (CallableMemberDescriptor descriptor : classDescriptor.getAllCallableMembers()) {
collectMissingImplementations(descriptor, abstractNoImpl, manyImpl);
}
}
private static void collectMissingImplementations(CallableMemberDescriptor descriptor, Set<CallableMemberDescriptor> abstractNoImpl, Set<CallableMemberDescriptor> manyImpl) {
if (descriptor.getKind().isReal()) {
if (descriptor.getModality() == Modality.ABSTRACT) {
//abstractNoImpl.add(descriptor);
}
}
else {
Collection<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverridenDeclarations(descriptor);
if (!descriptor.getKind().isReal()) {
Collection<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor);
if (overriddenDeclarations.size() == 0) {
throw new IllegalStateException();
throw new IllegalStateException("A 'fake override' must override something");
}
else if (overriddenDeclarations.size() == 1) {
CallableMemberDescriptor single = overriddenDeclarations.iterator().next();
@@ -312,7 +306,8 @@ public class OverrideResolver {
}
else {
List<CallableMemberDescriptor> nonAbstractManyImpl = Lists.newArrayList();
for (CallableMemberDescriptor overridden : overriddenDeclarations) {
Set<CallableMemberDescriptor> filteredOverriddenDeclarations = OverridingUtil.filterOverrides(Sets.newHashSet(overriddenDeclarations));
for (CallableMemberDescriptor overridden : filteredOverriddenDeclarations) {
if (overridden.getModality() != Modality.ABSTRACT) {
nonAbstractManyImpl.add(overridden);
}
@@ -393,6 +388,7 @@ public class OverrideResolver {
}
}
}
if (hasOverrideModifier && declared.getOverriddenDescriptors().size() == 0) {
if (!invisibleOverriddenDescriptors.get(declared).isEmpty()) {
CallableDescriptor descriptor = invisibleOverriddenDescriptors.values().iterator().next();
@@ -409,6 +405,74 @@ public class OverrideResolver {
}
}
private void checkParameterOverridesForAllClasses() {
List<MutableClassDescriptor> allClasses = Lists.newArrayList(context.getClasses().values());
allClasses.addAll(context.getObjects().values());
for (MutableClassDescriptor classDescriptor : allClasses) {
Collection<CallableMemberDescriptor> members = classDescriptor.getAllCallableMembers();
for (CallableMemberDescriptor member : members) {
checkOverridesForParameters(member);
}
}
}
private void checkOverridesForParameters(CallableMemberDescriptor declared) {
boolean fakeOverride = declared.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE;
if (!fakeOverride) {
// No check if the function is not marked as 'override'
JetModifierListOwner declaration =
(JetModifierListOwner) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), declared);
if (!declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) {
return;
}
}
// Let p1 be a parameter of the overriding function
// Let p2 be a parameter of the function being overridden
// Then
// a) p1 is not allowed to have a default value declared
// b) p1 must have the same name as p2
for (ValueParameterDescriptor parameterFromSubclass : declared.getValueParameters()) {
JetParameter parameter =
fakeOverride ? null :
(JetParameter) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), parameterFromSubclass);
JetClassOrObject classElement = fakeOverride ? (JetClassOrObject) BindingContextUtils
.descriptorToDeclaration(trace.getBindingContext(), declared.getContainingDeclaration()) : null;
if (parameterFromSubclass.declaresDefaultValue() && !fakeOverride) {
trace.report(DEFAULT_VALUE_NOT_ALLOWED_IN_OVERRIDE.on(parameter));
}
boolean superWithDefault = false;
for (ValueParameterDescriptor parameterFromSuperclass : parameterFromSubclass.getOverriddenDescriptors()) {
if (parameterFromSuperclass.declaresDefaultValue()) {
if (!superWithDefault) {
superWithDefault = true;
}
else {
if (fakeOverride) {
trace.report(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE.on(classElement, parameterFromSubclass));
}
else {
trace.report(MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES.on(parameter, parameterFromSubclass));
}
break;
}
}
if (!parameterFromSuperclass.getName().equals(parameterFromSubclass.getName())) {
if (fakeOverride) {
trace.report(DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES.on(classElement, declared.getOverriddenDescriptors(), parameterFromSuperclass.getIndex() + 1));
}
else {
trace.report(PARAMETER_NAME_CHANGED_ON_OVERRIDE.on(parameter, (ClassDescriptor) parameterFromSuperclass.getContainingDeclaration().getContainingDeclaration(), parameterFromSuperclass));
}
}
}
}
}
private boolean checkPropertyKind(CallableMemberDescriptor descriptor, boolean isVar) {
if (descriptor instanceof PropertyDescriptor) {
PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
+17 -6
View File
@@ -244,17 +244,17 @@ public class OverridingUtil {
}
/**
* Get overriden descriptors that are declarations or delegations.
* Get overridden descriptors that are declarations or delegations.
*
* @see CallableMemberDescriptor.Kind#isReal()
*/
public static Collection<CallableMemberDescriptor> getOverridenDeclarations(CallableMemberDescriptor descriptor) {
public static Collection<CallableMemberDescriptor> getOverriddenDeclarations(CallableMemberDescriptor descriptor) {
Map<ClassDescriptor, CallableMemberDescriptor> result = Maps.newHashMap();
getOverridenDeclarations(descriptor, result);
getOverriddenDeclarations(descriptor, result);
return result.values();
}
private static void getOverridenDeclarations(CallableMemberDescriptor descriptor, Map<ClassDescriptor, CallableMemberDescriptor> r) {
private static void getOverriddenDeclarations(CallableMemberDescriptor descriptor, Map<ClassDescriptor, CallableMemberDescriptor> r) {
if (descriptor.getKind().isReal()) {
r.put((ClassDescriptor) descriptor.getContainingDeclaration(), descriptor);
}
@@ -262,12 +262,23 @@ public class OverridingUtil {
if (descriptor.getOverriddenDescriptors().isEmpty()) {
throw new IllegalStateException();
}
for (CallableMemberDescriptor overriden : descriptor.getOverriddenDescriptors()) {
getOverridenDeclarations(overriden, r);
for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
getOverriddenDeclarations(overridden, r);
}
}
}
public static void bindOverride(CallableMemberDescriptor fromCurrent, CallableMemberDescriptor fromSupertype) {
fromCurrent.addOverriddenDescriptor(fromSupertype);
for (ValueParameterDescriptor parameterFromCurrent : fromCurrent.getValueParameters()) {
assert parameterFromCurrent.getIndex() < fromSupertype.getValueParameters().size()
: "An override relation between functions implies that they have the same number of value parameters";
ValueParameterDescriptor parameterFromSupertype = fromSupertype.getValueParameters().get(parameterFromCurrent.getIndex());
parameterFromCurrent.addOverriddenDescriptor(parameterFromSupertype);
}
}
public static class OverrideCompatibilityInfo {
public enum Result {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TemporaryBindingTrace.java
+2 -3
View File
@@ -25,10 +25,9 @@ public class TemporaryBindingTrace extends DelegatingBindingTrace {
return new TemporaryBindingTrace(trace);
}
private final BindingTrace trace;
protected final BindingTrace trace;
private TemporaryBindingTrace(BindingTrace trace) {
protected TemporaryBindingTrace(BindingTrace trace) {
super(trace.getBindingContext());
this.trace = trace;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+3 -5
View File
@@ -29,10 +29,7 @@ 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.WriteThroughScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeConstructor;
import org.jetbrains.jet.lang.types.TypeProjection;
import org.jetbrains.jet.lang.types.TypeUtils;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lexer.JetTokens;
@@ -379,7 +376,8 @@ public class TypeHierarchyResolver {
private void checkSupertypesForConsistency() {
for (MutableClassDescriptor mutableClassDescriptor : topologicalOrder) {
Multimap<TypeConstructor, TypeProjection> multimap = TypeUtils.buildDeepSubstitutionMultimap(mutableClassDescriptor.getDefaultType());
Multimap<TypeConstructor, TypeProjection> multimap = SubstitutionUtils
.buildDeepSubstitutionMultimap(mutableClassDescriptor.getDefaultType());
for (Map.Entry<TypeConstructor, Collection<TypeProjection>> entry : multimap.asMap().entrySet()) {
Collection<TypeProjection> projections = entry.getValue();
if (projections.size() > 1) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java
+2 -1
View File
@@ -69,6 +69,7 @@ public class TypeResolver {
JetTypeElement typeElement = typeReference.getTypeElement();
JetType type = resolveTypeElement(scope, annotations, typeElement, false, trace, checkBounds);
trace.record(BindingContext.TYPE, typeReference, type);
trace.record(BindingContext.TYPE_RESOLUTION_SCOPE, typeReference, scope);
return type;
}
@@ -243,7 +244,7 @@ public class TypeResolver {
List<TypeParameterDescriptor> parameters = constructor.getParameters();
if (parameters.size() > i) {
TypeParameterDescriptor parameterDescriptor = parameters.get(i);
arguments.add(TypeUtils.makeStarProjection(parameterDescriptor));
arguments.add(SubstitutionUtils.makeStarProjection(parameterDescriptor));
}
else {
arguments.add(new TypeProjection(Variance.OUT_VARIANCE, ErrorUtils.createErrorType("*")));
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallMaker.java
+12
View File
@@ -98,6 +98,12 @@ public class CallMaker {
return explicitReceiver;
}
@NotNull
@Override
public ReceiverDescriptor getThisObject() {
return ReceiverDescriptor.NO_RECEIVER;
}
@Override
public JetExpression getCalleeExpression() {
return calleeExpression;
@@ -199,6 +205,12 @@ public class CallMaker {
return explicitReceiver;
}
@NotNull
@Override
public ReceiverDescriptor getThisObject() {
return ReceiverDescriptor.NO_RECEIVER;
}
@Nullable
public JetExpression getCalleeExpression() {
return callElement.getCalleeExpression();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolutionContext.java
+10 -4
View File
@@ -20,21 +20,27 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.psi.Call;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
/**
* @author svtk
*/
public final class CallResolutionContext<D extends CallableDescriptor> extends ResolutionContext {
public final class CallResolutionContext<D extends CallableDescriptor, F extends D> extends ResolutionContext {
/*package*/ final ResolvedCallImpl<D> candidateCall;
/*package*/ final TracingStrategy tracing;
/*package*/ ReceiverDescriptor receiverForVariableAsFunctionSecondCall = ReceiverDescriptor.NO_RECEIVER;
public CallResolutionContext(@NotNull ResolvedCallImpl<D> candidateCall, @NotNull ResolutionTask<D> task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) {
private CallResolutionContext(@NotNull ResolvedCallImpl<D> candidateCall, @NotNull ResolutionTask<D, F> task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) {
super(trace, task.scope, call, task.expectedType, task.dataFlowInfo);
this.candidateCall = candidateCall;
this.tracing = tracing;
}
public CallResolutionContext(@NotNull ResolvedCallImpl<D> candidateCall, @NotNull ResolutionTask<D> task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) {
this(candidateCall, task, trace, tracing, task.call);
public static <D extends CallableDescriptor, F extends D> CallResolutionContext<D, F> create(@NotNull ResolvedCallImpl<D> candidateCall, @NotNull ResolutionTask<D, F> task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing, @NotNull Call call) {
return new CallResolutionContext<D, F>(candidateCall, task, trace, tracing, call);
}
public static <D extends CallableDescriptor, F extends D> CallResolutionContext<D, F> create(@NotNull ResolvedCallImpl<D> candidateCall, @NotNull ResolutionTask<D, F> task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) {
return create(candidateCall, task, trace, tracing, task.call);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
+101 -83
View File
@@ -102,16 +102,16 @@ public class CallResolver {
if (referencedName == null) {
return OverloadResolutionResultsImpl.nameNotFound();
}
List<MemberPrioritizer<VariableDescriptor>> memberPrioritizers = Lists.newArrayList();
List<CallableDescriptorCollector<? extends VariableDescriptor>> callableDescriptorCollectors = Lists.newArrayList();
if (nameExpression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER) {
referencedName = referencedName.substring(1);
memberPrioritizers.add(MemberPrioritizers.PROPERTY_TASK_PRIORITIZER);
callableDescriptorCollectors.add(CallableDescriptorCollectors.PROPERTIES);
}
else {
memberPrioritizers.add(MemberPrioritizers.VARIABLE_TASK_PRIORITIZER);
callableDescriptorCollectors.add(CallableDescriptorCollectors.VARIABLES);
}
List<ResolutionTask<VariableDescriptor>> prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, referencedName, nameExpression, memberPrioritizers);
return doResolveCall(context, prioritizedTasks, CallTransformationStrategy.PROPERTY_CALL_TRANSFORMATION_STRATEGY, nameExpression);
List<ResolutionTask<VariableDescriptor, VariableDescriptor>> prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, referencedName, nameExpression, callableDescriptorCollectors);
return doResolveCall(context, prioritizedTasks, CallTransformer.PROPERTY_CALL_TRANSFORMER, nameExpression);
}
@NotNull
@@ -119,9 +119,8 @@ public class CallResolver {
@NotNull BasicResolutionContext context,
@NotNull final JetReferenceExpression functionReference,
@NotNull String name) {
List<ResolutionTask<FunctionDescriptor>> tasks = TaskPrioritizer.computePrioritizedTasks(
context, name, functionReference, Collections.singletonList(MemberPrioritizers.FUNCTION_TASK_PRIORITIZER));
return doResolveCall(context, tasks, CallTransformationStrategy.FUNCTION_CALL_TRANSFORMATION_STRATEGY, functionReference);
List<ResolutionTask<CallableDescriptor, FunctionDescriptor>> tasks = TaskPrioritizer.computePrioritizedTasks(context, name, functionReference, CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES);
return doResolveCall(context, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, functionReference);
}
@NotNull
@@ -131,7 +130,7 @@ public class CallResolver {
@NotNull
public OverloadResolutionResults<FunctionDescriptor> resolveFunctionCall(@NotNull BasicResolutionContext context) {
List<ResolutionTask<FunctionDescriptor>> prioritizedTasks;
List<ResolutionTask<CallableDescriptor, FunctionDescriptor>> prioritizedTasks;
JetExpression calleeExpression = context.call.getCalleeExpression();
final JetReferenceExpression functionReference;
@@ -142,7 +141,7 @@ public class CallResolver {
String name = expression.getReferencedName();
if (name == null) return checkArgumentTypesAndFail(context);
prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, name, functionReference, Collections.singletonList(MemberPrioritizers.FUNCTION_TASK_PRIORITIZER));
prioritizedTasks = TaskPrioritizer.computePrioritizedTasks(context, name, functionReference, CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES);
ResolutionTask.DescriptorCheckStrategy abstractConstructorCheck = new ResolutionTask.DescriptorCheckStrategy() {
@Override
public <D extends CallableDescriptor> boolean performAdvancedChecks(D descriptor, BindingTrace trace, TracingStrategy tracing) {
@@ -184,8 +183,11 @@ public class CallResolver {
context.trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn));
return checkArgumentTypesAndFail(context);
}
Collection<ResolutionCandidate<FunctionDescriptor>> candidates = TaskPrioritizer.<FunctionDescriptor>convertWithImpliedThis(context.scope, Collections.<ReceiverDescriptor>singletonList(NO_RECEIVER), constructors);
prioritizedTasks.add(new ResolutionTask<FunctionDescriptor>(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY
Collection<ResolutionCandidate<CallableDescriptor>> candidates = TaskPrioritizer.<CallableDescriptor>convertWithImpliedThis(context.scope, Collections.<ReceiverDescriptor>singletonList(NO_RECEIVER), constructors);
for (ResolutionCandidate<CallableDescriptor> candidate : candidates) {
candidate.setSafeCall(JetPsiUtil.isSafeCall(context.call));
}
prioritizedTasks.add(new ResolutionTask<CallableDescriptor, FunctionDescriptor>(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY
}
else {
context.trace.report(NOT_A_CLASS.on(calleeExpression));
@@ -206,8 +208,8 @@ public class CallResolver {
context.trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn));
return checkArgumentTypesAndFail(context);
}
List<ResolutionCandidate<FunctionDescriptor>> candidates = ResolutionCandidate.<FunctionDescriptor>convertCollection(constructors);
prioritizedTasks = Collections.singletonList(new ResolutionTask<FunctionDescriptor>(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY
List<ResolutionCandidate<CallableDescriptor>> candidates = ResolutionCandidate.<CallableDescriptor>convertCollection(constructors, JetPsiUtil.isSafeCall(context.call));
prioritizedTasks = Collections.singletonList(new ResolutionTask<CallableDescriptor, FunctionDescriptor>(candidates, functionReference, context)); // !! DataFlowInfo.EMPTY
}
else if (calleeExpression != null) {
// Here we handle the case where the callee expression must be something of type function, e.g. (foo.bar())(1, 2)
@@ -222,16 +224,17 @@ public class CallResolver {
}
FunctionDescriptorImpl functionDescriptor = new ExpressionAsFunctionDescriptor(context.scope.getContainingDeclaration(), "[for expression " + calleeExpression.getText() + "]");
FunctionDescriptorUtil.initializeFromFunctionType(functionDescriptor, calleeType, NO_RECEIVER);
ResolutionCandidate<FunctionDescriptor> resolutionCandidate = ResolutionCandidate.<FunctionDescriptor>create(functionDescriptor);
FunctionDescriptorUtil.initializeFromFunctionType(functionDescriptor, calleeType, NO_RECEIVER, Modality.FINAL, Visibilities.LOCAL);
ResolutionCandidate<CallableDescriptor> resolutionCandidate = ResolutionCandidate.<CallableDescriptor>create(functionDescriptor, JetPsiUtil.isSafeCall(context.call));
resolutionCandidate.setReceiverArgument(context.call.getExplicitReceiver());
resolutionCandidate.setExplicitReceiverKind(ExplicitReceiverKind.RECEIVER_ARGUMENT);
// strictly speaking, this is a hack:
// we need to pass a reference, but there's no reference in the PSI,
// so we wrap what we have into a fake reference and pass it on (unwrap on the other end)
functionReference = new JetFakeReference(calleeExpression);
prioritizedTasks = Collections.singletonList(new ResolutionTask<FunctionDescriptor>(Collections.singleton(resolutionCandidate), functionReference, context));
prioritizedTasks = Collections.singletonList(new ResolutionTask<CallableDescriptor, FunctionDescriptor>(Collections.singleton(resolutionCandidate), functionReference, context));
}
else {
// checkTypesWithNoCallee(trace, scope, call);
@@ -239,7 +242,7 @@ public class CallResolver {
}
}
return doResolveCall(context, prioritizedTasks, CallTransformationStrategy.FUNCTION_CALL_TRANSFORMATION_STRATEGY, functionReference);
return doResolveCall(context, prioritizedTasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, functionReference);
}
private <D extends CallableDescriptor> OverloadResolutionResults<D> checkArgumentTypesAndFail(BasicResolutionContext context) {
@@ -248,10 +251,10 @@ public class CallResolver {
}
@NotNull
private <D extends CallableDescriptor> OverloadResolutionResults<D> doResolveCall(
private <D extends CallableDescriptor, F extends D> OverloadResolutionResults<F> doResolveCall(
@NotNull final BasicResolutionContext context,
@NotNull final List<ResolutionTask<D>> prioritizedTasks, // high to low priority
@NotNull CallTransformationStrategy<D, D> callTransformationStrategy,
@NotNull final List<ResolutionTask<D, F>> prioritizedTasks, // high to low priority
@NotNull CallTransformer<D, F> callTransformer,
@NotNull final JetReferenceExpression reference) {
ResolutionDebugInfo.Data debugInfo = ResolutionDebugInfo.create();
@@ -265,10 +268,11 @@ public class CallResolver {
debugInfo.set(ResolutionDebugInfo.TASKS, prioritizedTasks);
TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null;
OverloadResolutionResultsImpl<D> resultsForFirstNonemptyCandidateSet = null;
for (ResolutionTask<D> task : prioritizedTasks) {
OverloadResolutionResultsImpl<F> resultsForFirstNonemptyCandidateSet = null;
for (ResolutionTask<D, F> task : prioritizedTasks) {
TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace);
OverloadResolutionResultsImpl<D> results = performResolutionGuardedForExtraFunctionLiteralArguments(task.withTrace(temporaryTrace), callTransformationStrategy);
OverloadResolutionResultsImpl<F> results = performResolutionGuardedForExtraFunctionLiteralArguments(task.withTrace(temporaryTrace),
callTransformer);
if (results.isSuccess() || results.isAmbiguity()) {
temporaryTrace.commit();
@@ -294,15 +298,15 @@ public class CallResolver {
context.trace.report(UNRESOLVED_REFERENCE.on(reference));
checkTypesWithNoCallee(context);
}
return resultsForFirstNonemptyCandidateSet != null ? resultsForFirstNonemptyCandidateSet : OverloadResolutionResultsImpl.<D>nameNotFound();
return resultsForFirstNonemptyCandidateSet != null ? resultsForFirstNonemptyCandidateSet : OverloadResolutionResultsImpl.<F>nameNotFound();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@NotNull
private <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> performResolutionGuardedForExtraFunctionLiteralArguments(@NotNull ResolutionTask<D> task,
@NotNull CallTransformationStrategy<D, D> callTransformationStrategy) {
OverloadResolutionResultsImpl<D> results = performResolution(task, callTransformationStrategy);
private <D extends CallableDescriptor, F extends D> OverloadResolutionResultsImpl<F> performResolutionGuardedForExtraFunctionLiteralArguments(@NotNull ResolutionTask<D, F> task,
@NotNull CallTransformer<D, F> callTransformer) {
OverloadResolutionResultsImpl<F> results = performResolution(task, callTransformer);
// If resolution fails, we should check for some of the following situations:
// class A {
@@ -327,16 +331,16 @@ public class CallResolver {
// Now, we try to remove this argument and see if it helps
Collection<ResolutionCandidate<D>> newCandidates = Lists.newArrayList();
for (ResolutionCandidate<D> candidate : task.getCandidates()) {
newCandidates.add(ResolutionCandidate.create(candidate.getDescriptor()));
newCandidates.add(ResolutionCandidate.create(candidate.getDescriptor(), candidate.isSafeCall())); //todo check receivers are not necessary
}
ResolutionTask<D> newContext = new ResolutionTask<D>(newCandidates, task.reference, TemporaryBindingTrace.create(task.trace), task.scope, new DelegatingCall(task.call) {
ResolutionTask<D, F> newContext = new ResolutionTask<D, F>(newCandidates, task.reference, TemporaryBindingTrace.create(task.trace), task.scope, new DelegatingCall(task.call) {
@NotNull
@Override
public List<JetExpression> getFunctionLiteralArguments() {
return Collections.emptyList();
}
}, task.expectedType, task.dataFlowInfo);
OverloadResolutionResultsImpl<D> resultsWithFunctionLiteralsStripped = performResolution(newContext, callTransformationStrategy);
OverloadResolutionResultsImpl<F> resultsWithFunctionLiteralsStripped = performResolution(newContext, callTransformer);
if (resultsWithFunctionLiteralsStripped.isSuccess() || resultsWithFunctionLiteralsStripped.isAmbiguity()) {
task.tracing.danglingFunctionLiteralArgumentSuspected(task.trace, task.call.getFunctionLiteralArguments());
}
@@ -346,23 +350,28 @@ public class CallResolver {
}
@NotNull
private <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> performResolution(@NotNull ResolutionTask<D> task,
@NotNull CallTransformationStrategy<D, D> callTransformationStrategy) {
private <D extends CallableDescriptor, F extends D> OverloadResolutionResultsImpl<F> performResolution(@NotNull ResolutionTask<D, F> task,
@NotNull CallTransformer<D, F> callTransformer) {
for (ResolutionCandidate<D> resolutionCandidate : task.getCandidates()) {
TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(task.trace);
CallResolutionContext<D> context = callTransformationStrategy.createCallContext(resolutionCandidate, task, temporaryTrace, task.tracing);
performResolutionForCandidateCall(context, task, temporaryTrace);
Collection<CallResolutionContext<D, F>> contexts = callTransformer.createCallContexts(resolutionCandidate, task, temporaryTrace);
Collection<ResolvedCallWithTrace<F>> calls = Lists.newArrayList();
for (CallResolutionContext<D, F> context : contexts) {
Collection<ResolvedCallImpl<D>> calls = callTransformationStrategy.transformResultCall(context, this, task);
for (ResolvedCallImpl<D> call : calls) {
task.getResolvedCallMap().put(resolutionCandidate, call);
performResolutionForCandidateCall(context, task);
calls.addAll(callTransformer.transformCall(context, this, task));
}
for (ResolvedCallWithTrace<F> call : calls) {
task.tracing.bindResolvedCall(call.getTrace(), call);
task.getResolvedCalls().add(call);
}
}
Set<ResolvedCallImpl<D>> successfulCandidates = Sets.newLinkedHashSet();
Set<ResolvedCallImpl<D>> failedCandidates = Sets.newLinkedHashSet();
for (ResolvedCallImpl<D> candidateCall : task.getResolvedCallMap().values()) {
Set<ResolvedCallWithTrace<F>> successfulCandidates = Sets.newLinkedHashSet();
Set<ResolvedCallWithTrace<F>> failedCandidates = Sets.newLinkedHashSet();
for (ResolvedCallWithTrace<F> candidateCall : task.getResolvedCalls()) {
ResolutionStatus status = candidateCall.getStatus();
if (status.isSuccess()) {
successfulCandidates.add(candidateCall);
@@ -373,23 +382,19 @@ public class CallResolver {
}
}
OverloadResolutionResultsImpl<D> results = computeResultAndReportErrors(task.trace, task.tracing, successfulCandidates, failedCandidates);
OverloadResolutionResultsImpl<F> results = computeResultAndReportErrors(task.trace, task.tracing, successfulCandidates, failedCandidates);
if (!results.isSingleResult()) {
checkTypesWithNoCallee(task.toBasic());
}
return results;
}
private <D extends CallableDescriptor> void performResolutionForCandidateCall(@NotNull CallResolutionContext<D> context,
@NotNull ResolutionTask<D> task,
@NotNull TemporaryBindingTrace temporaryTrace) {
private <D extends CallableDescriptor, F extends D> void performResolutionForCandidateCall(@NotNull CallResolutionContext<D, F> context,
@NotNull ResolutionTask<D, F> task) {
ResolvedCallImpl<D> candidateCall = context.candidateCall;
candidateCall.setTrace(temporaryTrace);
D candidate = candidateCall.getCandidateDescriptor();
context.tracing.bindReference(context.trace, candidateCall);
if (ErrorUtils.isError(candidate)) {
candidateCall.addStatus(SUCCESS);
checkTypesWithNoCallee(context.toBasic());
@@ -477,7 +482,7 @@ public class CallResolver {
recordAutoCastIfNecessary(candidateCall.getThisObject(), candidateCall.getTrace());
}
private <D extends CallableDescriptor> ResolutionStatus inferTypeArguments(CallResolutionContext<D> context) {
private <D extends CallableDescriptor, F extends D> ResolutionStatus inferTypeArguments(CallResolutionContext<D, F> context) {
ResolvedCallImpl<D> candidateCall = context.candidateCall;
D candidate = candidateCall.getCandidateDescriptor();
@@ -624,23 +629,37 @@ public class CallResolver {
}
}
private <D extends CallableDescriptor> ResolutionStatus checkAllValueArguments(CallResolutionContext<D> context) {
private <D extends CallableDescriptor, F extends D> ResolutionStatus checkAllValueArguments(CallResolutionContext<D, F> context) {
ResolutionStatus result = checkValueArgumentTypes(context);
ResolvedCall candidateCall = context.candidateCall;
result = result.combine(checkReceiver(context, candidateCall.getResultingDescriptor().getReceiverParameter(), candidateCall.getReceiverArgument()));
result = result.combine(checkReceiver(context, candidateCall.getResultingDescriptor().getExpectedThisObject(), candidateCall.getThisObject()));
ResolvedCall<D> candidateCall = context.candidateCall;
// Comment about a very special case.
// Call 'b.foo(1)' where class 'Foo' has an extension member 'fun B.invoke(Int)' should be checked two times for safe call (in 'checkReceiver'), because
// both 'b' (receiver) and 'foo' (this object) might be nullable. In the first case we mark dot, in the second 'foo'.
// Class 'CallForImplicitInvoke' helps up to recognise this case, and parameter 'implicitInvokeCheck' helps us to distinguish whether we check receiver or this object.
result = result.combine(checkReceiver(context, candidateCall, candidateCall.getResultingDescriptor().getReceiverParameter(), candidateCall.getReceiverArgument(),
candidateCall.getExplicitReceiverKind().isReceiver(), false));
result = result.combine(checkReceiver(context, candidateCall, candidateCall.getResultingDescriptor().getExpectedThisObject(), candidateCall.getThisObject(),
candidateCall.getExplicitReceiverKind().isThisObject(),
// for the invocation 'foo(1)' where foo is a variable of function type we should mark 'foo' if there is unsafe call error
context.call instanceof CallTransformer.CallForImplicitInvoke));
return result;
}
private <D extends CallableDescriptor> ResolutionStatus checkReceiver(CallResolutionContext<D> context, ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument) {
private <D extends CallableDescriptor, F extends D> ResolutionStatus checkReceiver(CallResolutionContext<D, F> context, ResolvedCall<D> candidateCall,
ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument,
boolean isExplicitReceiver, boolean implicitInvokeCheck) {
ResolutionStatus result = SUCCESS;
if (receiverParameter.exists() && receiverArgument.exists()) {
ASTNode callOperationNode = context.call.getCallOperationNode();
boolean safeAccess = callOperationNode != null && callOperationNode.getElementType() == JetTokens.SAFE_ACCESS;
boolean safeAccess = isExplicitReceiver && !implicitInvokeCheck && candidateCall.isSafeCall();
JetType receiverArgumentType = receiverArgument.getType();
AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.candidateCall.getTrace().getBindingContext());
if (!safeAccess && !receiverParameter.getType().isNullable() && !autoCastService.isNotNull(receiverArgument)) {
context.tracing.unsafeCall(context.candidateCall.getTrace(), receiverArgumentType);
context.tracing.unsafeCall(context.candidateCall.getTrace(), receiverArgumentType, implicitInvokeCheck);
result = UNSAFE_CALL_ERROR;
}
else {
@@ -652,7 +671,6 @@ public class CallResolver {
result = OTHER_ERROR;
}
}
if (safeAccess && (receiverParameter.getType().isNullable() || !receiverArgumentType.isNullable())) {
context.tracing.unnecessarySafeCall(context.candidateCall.getTrace(), receiverArgumentType);
}
@@ -660,7 +678,7 @@ public class CallResolver {
return result;
}
private <D extends CallableDescriptor> ResolutionStatus checkValueArgumentTypes(CallResolutionContext<D> context) {
private <D extends CallableDescriptor, F extends D> ResolutionStatus checkValueArgumentTypes(CallResolutionContext<D, F> context) {
ResolutionStatus result = SUCCESS;
for (Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> entry : context.candidateCall.getValueArguments().entrySet()) {
ValueParameterDescriptor parameterDescriptor = entry.getKey();
@@ -734,8 +752,8 @@ public class CallResolver {
private <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> computeResultAndReportErrors(
BindingTrace trace,
TracingStrategy tracing,
Set<ResolvedCallImpl<D>> successfulCandidates,
Set<ResolvedCallImpl<D>> failedCandidates) {
Set<ResolvedCallWithTrace<D>> successfulCandidates,
Set<ResolvedCallWithTrace<D>> failedCandidates) {
// TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific
if (successfulCandidates.size() > 0) {
@@ -756,8 +774,8 @@ public class CallResolver {
// and some are not OK at all. In this case we'd like to say "unsafe call" rather than "none applicable"
// Used to be: weak errors. Generalized for future extensions
for (EnumSet<ResolutionStatus> severityLevel : SEVERITY_LEVELS) {
Set<ResolvedCallImpl<D>> thisLevel = Sets.newLinkedHashSet();
for (ResolvedCallImpl<D> candidate : failedCandidates) {
Set<ResolvedCallWithTrace<D>> thisLevel = Sets.newLinkedHashSet();
for (ResolvedCallWithTrace<D> candidate : failedCandidates) {
if (severityLevel.contains(candidate.getStatus())) {
thisLevel.add(candidate);
}
@@ -777,7 +795,7 @@ public class CallResolver {
assert false : "Should not be reachable, cause every status must belong to some level";
Set<ResolvedCallImpl<D>> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE);
Set<ResolvedCallWithTrace<D>> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE);
if (noOverrides.size() != 1) {
tracing.noneApplicable(trace, noOverrides);
tracing.recordAmbiguity(trace, noOverrides);
@@ -787,7 +805,7 @@ public class CallResolver {
failedCandidates = noOverrides;
}
ResolvedCallImpl<D> failed = failedCandidates.iterator().next();
ResolvedCallWithTrace<D> failed = failedCandidates.iterator().next();
failed.getTrace().commit();
return OverloadResolutionResultsImpl.singleFailedCandidate(failed);
}
@@ -797,18 +815,18 @@ public class CallResolver {
}
}
private static <D extends CallableDescriptor> boolean allClean(Collection<ResolvedCallImpl<D>> results) {
for (ResolvedCallImpl<D> result : results) {
private static <D extends CallableDescriptor> boolean allClean(Collection<ResolvedCallWithTrace<D>> results) {
for (ResolvedCallWithTrace<D> result : results) {
if (result.isDirty()) return false;
}
return true;
}
private <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> chooseAndReportMaximallySpecific(Set<ResolvedCallImpl<D>> candidates, boolean discriminateGenerics) {
private <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> chooseAndReportMaximallySpecific(Set<ResolvedCallWithTrace<D>> candidates, boolean discriminateGenerics) {
if (candidates.size() != 1) {
Set<ResolvedCallImpl<D>> cleanCandidates = Sets.newLinkedHashSet(candidates);
for (Iterator<ResolvedCallImpl<D>> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) {
ResolvedCallImpl<D> candidate = iterator.next();
Set<ResolvedCallWithTrace<D>> cleanCandidates = Sets.newLinkedHashSet(candidates);
for (Iterator<ResolvedCallWithTrace<D>> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) {
ResolvedCallWithTrace<D> candidate = iterator.next();
if (candidate.isDirty()) {
iterator.remove();
}
@@ -817,27 +835,28 @@ public class CallResolver {
if (cleanCandidates.isEmpty()) {
cleanCandidates = candidates;
}
ResolvedCallImpl<D> maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false);
ResolvedCallWithTrace<D> maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false);
if (maximallySpecific != null) {
return OverloadResolutionResultsImpl.success(maximallySpecific);
}
if (discriminateGenerics) {
ResolvedCallImpl<D> maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true);
ResolvedCallWithTrace<D> maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true);
if (maximallySpecificGenericsDiscriminated != null) {
return OverloadResolutionResultsImpl.success(maximallySpecificGenericsDiscriminated);
}
}
Set<ResolvedCallImpl<D>> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT);
Set<ResolvedCallWithTrace<D>> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT);
return OverloadResolutionResultsImpl.ambiguity(noOverrides);
}
else {
ResolvedCallImpl<D> result = candidates.iterator().next();
ResolvedCallWithTrace<D> result = candidates.iterator().next();
TemporaryBindingTrace temporaryTrace = result.getTrace();
temporaryTrace.commit();
return OverloadResolutionResultsImpl.success(result);
}
}
@@ -868,20 +887,19 @@ public class CallResolver {
BindingTraceContext trace = new BindingTraceContext();
TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(trace);
Set<ResolvedCallImpl<FunctionDescriptor>> calls = Sets.newLinkedHashSet();
Set<ResolvedCallWithTrace<FunctionDescriptor>> calls = Sets.newLinkedHashSet();
for (ResolutionCandidate<FunctionDescriptor> candidate : candidates) {
ResolvedCallImpl<FunctionDescriptor> call = ResolvedCallImpl.create(candidate);
call.setTrace(temporaryBindingTrace);
ResolvedCallImpl<FunctionDescriptor> call = ResolvedCallImpl.create(candidate, temporaryBindingTrace);
calls.add(call);
}
return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, calls, Collections.<ResolvedCallImpl<FunctionDescriptor>>emptySet());
return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, calls, Collections.<ResolvedCallWithTrace<FunctionDescriptor>>emptySet());
}
private List<ResolutionCandidate<FunctionDescriptor>> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver,
String name, List<JetType> parameterTypes) {
List<ResolutionCandidate<FunctionDescriptor>> result = Lists.newArrayList();
if (receiver.exists()) {
Collection<ResolutionCandidate<FunctionDescriptor>> extensionFunctionDescriptors = ResolutionCandidate.convertCollection(scope.getFunctions(name));
Collection<ResolutionCandidate<FunctionDescriptor>> extensionFunctionDescriptors = ResolutionCandidate.convertCollection(scope.getFunctions(name), false);
List<ResolutionCandidate<FunctionDescriptor>> nonlocal = Lists.newArrayList();
List<ResolutionCandidate<FunctionDescriptor>> local = Lists.newArrayList();
TaskPrioritizer.splitLexicallyLocalDescriptors(extensionFunctionDescriptors, scope.getContainingDeclaration(), local, nonlocal);
@@ -891,7 +909,7 @@ public class CallResolver {
return result;
}
Collection<ResolutionCandidate<FunctionDescriptor>> functionDescriptors = ResolutionCandidate.convertCollection(receiver.getType().getMemberScope().getFunctions(name));
Collection<ResolutionCandidate<FunctionDescriptor>> functionDescriptors = ResolutionCandidate.convertCollection(receiver.getType().getMemberScope().getFunctions(name), false);
if (lookupExactSignature(functionDescriptors, parameterTypes, result)) {
return result;
@@ -900,7 +918,7 @@ public class CallResolver {
return result;
}
else {
lookupExactSignature(ResolutionCandidate.convertCollection(scope.getFunctions(name)), parameterTypes, result);
lookupExactSignature(ResolutionCandidate.convertCollection(scope.getFunctions(name), false), parameterTypes, result);
return result;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformationStrategy.java
-118
View File
@@ -1,118 +0,0 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.calls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* @author svtk
*/
public interface CallTransformationStrategy<D extends CallableDescriptor, R extends D> {
@NotNull
CallResolutionContext<D> createCallContext(@NotNull ResolutionCandidate<D> candidate,
@NotNull ResolutionTask<D> task,
@NotNull BindingTrace trace,
@NotNull TracingStrategy tracing);
@NotNull
Collection<ResolvedCallImpl<R>> transformResultCall(@NotNull CallResolutionContext<D> callResolutionContext,
@NotNull CallResolver callResolver,
@NotNull ResolutionTask<D> task);
CallTransformationStrategy<VariableDescriptor, VariableDescriptor>
PROPERTY_CALL_TRANSFORMATION_STRATEGY = new CallTransformationStrategy<VariableDescriptor, VariableDescriptor>() {
@NotNull
@Override
public CallResolutionContext<VariableDescriptor> createCallContext(@NotNull ResolutionCandidate<VariableDescriptor> candidate,
@NotNull ResolutionTask<VariableDescriptor> task, @NotNull BindingTrace trace, @NotNull TracingStrategy tracing) {
ResolvedCallImpl<VariableDescriptor> candidateCall = ResolvedCallImpl.create(candidate);
return new CallResolutionContext<VariableDescriptor>(candidateCall, task, trace, tracing);
}
@NotNull
@Override
public Collection<ResolvedCallImpl<VariableDescriptor>> transformResultCall(@NotNull CallResolutionContext<VariableDescriptor> context,
@NotNull CallResolver callResolver, @NotNull ResolutionTask<VariableDescriptor> task) {
return Collections.singleton(context.candidateCall);
}
};
CallTransformationStrategy<FunctionDescriptor, FunctionDescriptor>
FUNCTION_CALL_TRANSFORMATION_STRATEGY = new CallTransformationStrategy<FunctionDescriptor, FunctionDescriptor>() {
@NotNull
@Override
public CallResolutionContext<FunctionDescriptor> createCallContext(@NotNull ResolutionCandidate<FunctionDescriptor> candidate,
@NotNull ResolutionTask<FunctionDescriptor> task,
@NotNull BindingTrace trace,
@NotNull TracingStrategy tracing) {
if (candidate.getDescriptor() instanceof FunctionDescriptor) {
return new CallResolutionContext<FunctionDescriptor>(ResolvedCallImpl.create(candidate), task, trace, tracing);
}
assert candidate.getDescriptor() instanceof VariableDescriptor;
Call propertyCall = new DelegatingCall(task.call) {
@Override
public JetValueArgumentList getValueArgumentList() {
return null;
}
@NotNull
@Override
public List<JetExpression> getFunctionLiteralArguments() {
return Collections.emptyList();
}
@NotNull
@Override
public List<JetTypeProjection> getTypeArguments() {
return Collections.emptyList();
}
@Override
public JetTypeArgumentList getTypeArgumentList() {
return null;
}
};
return new CallResolutionContext<FunctionDescriptor>(ResolvedCallImpl.create(candidate), task, trace, tracing, propertyCall);
}
@NotNull
@Override
public Collection<ResolvedCallImpl<FunctionDescriptor>> transformResultCall(@NotNull CallResolutionContext<FunctionDescriptor> context,
@NotNull CallResolver callResolver, @NotNull ResolutionTask<FunctionDescriptor> task) {
FunctionDescriptor descriptor = context.candidateCall.getCandidateDescriptor();
if (descriptor instanceof FunctionDescriptor) {
return Collections.singleton(context.candidateCall);
}
assert descriptor instanceof VariableDescriptor;
BasicResolutionContext basicResolutionContext =
BasicResolutionContext.create(context.trace, context.scope, task.call, context.expectedType, context.dataFlowInfo);
OverloadResolutionResults<FunctionDescriptor> results =
callResolver.resolveCallWithGivenName(basicResolutionContext, task.reference, "invoke");
return ((OverloadResolutionResultsImpl<FunctionDescriptor>)results).getResultingCalls();
}
};
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallTransformer.java
+245
View File
@@ -0,0 +1,245 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.calls;
import com.google.common.base.Function;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* CallTransformer treats specially 'variable as function' call case, other cases keeps unchanged (base realization).
*
* For the call 'b.foo(1)' where foo is a variable that has method 'invoke' (for example of function type)
* CallTransformer creates two contexts, two calls in each, and performs second ('invoke') call resolution:
*
* context#1. calls: 'b.foo' 'invoke(1)'
* context#2. calls: 'foo' 'b.invoke(1)'
*
* If success VariableAsFunctionResolvedCall is created.
*
* @author svtk
*/
public class CallTransformer<D extends CallableDescriptor, F extends D> {
private CallTransformer() {}
/**
* Returns two contexts for 'variable as function' case (in FUNCTION_CALL_TRANSFORMER), one context otherwise
*/
@NotNull
public Collection<CallResolutionContext<D, F>> createCallContexts(@NotNull ResolutionCandidate<D> candidate,
@NotNull ResolutionTask<D, F> task,
@NotNull TemporaryBindingTrace temporaryTrace) {
ResolvedCallImpl<D> candidateCall = ResolvedCallImpl.create(candidate, temporaryTrace);
return Collections.singleton(CallResolutionContext.create(candidateCall, task, temporaryTrace, task.tracing));
}
/**
* Returns collection of resolved calls for 'invoke' for 'variable as function' case (in FUNCTION_CALL_TRANSFORMER),
* the resolved call from callResolutionContext otherwise
*/
@NotNull
public Collection<ResolvedCallWithTrace<F>> transformCall(@NotNull CallResolutionContext<D, F> callResolutionContext,
@NotNull CallResolver callResolver,
@NotNull ResolutionTask<D, F> task) {
return Collections.singleton((ResolvedCallWithTrace<F>)callResolutionContext.candidateCall);
}
public static CallTransformer<VariableDescriptor, VariableDescriptor> PROPERTY_CALL_TRANSFORMER = new CallTransformer<VariableDescriptor, VariableDescriptor>();
public static CallTransformer<CallableDescriptor, FunctionDescriptor> FUNCTION_CALL_TRANSFORMER = new CallTransformer<CallableDescriptor, FunctionDescriptor>() {
@NotNull
@Override
public Collection<CallResolutionContext<CallableDescriptor, FunctionDescriptor>> createCallContexts(@NotNull ResolutionCandidate<CallableDescriptor> candidate,
@NotNull ResolutionTask<CallableDescriptor, FunctionDescriptor> task, @NotNull TemporaryBindingTrace temporaryTrace) {
if (candidate.getDescriptor() instanceof FunctionDescriptor) {
return super.createCallContexts(candidate, task, temporaryTrace);
}
assert candidate.getDescriptor() instanceof VariableDescriptor;
boolean hasReceiver = candidate.getReceiverArgument().exists();
Call variableCall = stripCallArguments(task);
if (!hasReceiver) {
CallResolutionContext<CallableDescriptor, FunctionDescriptor> context = CallResolutionContext.create(
ResolvedCallImpl.create(candidate, temporaryTrace), task, temporaryTrace, task.tracing, variableCall);
return Collections.singleton(context);
}
Call variableCallWithoutReceiver = stripReceiver(variableCall);
CallResolutionContext<CallableDescriptor, FunctionDescriptor> contextWithReceiver = createContextWithChainedTrace(
candidate, variableCall, temporaryTrace, task);
ResolutionCandidate<CallableDescriptor> candidateWithoutReceiver = ResolutionCandidate.create(
candidate.getDescriptor(), candidate.getThisObject(), ReceiverDescriptor.NO_RECEIVER, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, false);
CallResolutionContext<CallableDescriptor, FunctionDescriptor> contextWithoutReceiver = createContextWithChainedTrace(
candidateWithoutReceiver, variableCallWithoutReceiver, temporaryTrace, task);
contextWithoutReceiver.receiverForVariableAsFunctionSecondCall = variableCall.getExplicitReceiver();
return Lists.newArrayList(contextWithReceiver, contextWithoutReceiver);
}
private CallResolutionContext<CallableDescriptor, FunctionDescriptor> createContextWithChainedTrace(ResolutionCandidate<CallableDescriptor> candidate,
Call call, TemporaryBindingTrace temporaryTrace, ResolutionTask<CallableDescriptor, FunctionDescriptor> task) {
ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace);
ResolvedCallImpl<CallableDescriptor> resolvedCall = ResolvedCallImpl.create(candidate, chainedTrace);
return CallResolutionContext.create(resolvedCall, task, chainedTrace, task.tracing, call);
}
private Call stripCallArguments(@NotNull ResolutionTask<CallableDescriptor, FunctionDescriptor> task) {
return new DelegatingCall(task.call) {
@Override
public JetValueArgumentList getValueArgumentList() {
return null;
}
@NotNull
@Override
public List<? extends ValueArgument> getValueArguments() {
return Collections.emptyList();
}
@NotNull
@Override
public List<JetExpression> getFunctionLiteralArguments() {
return Collections.emptyList();
}
@NotNull
@Override
public List<JetTypeProjection> getTypeArguments() {
return Collections.emptyList();
}
@Override
public JetTypeArgumentList getTypeArgumentList() {
return null;
}
};
}
private Call stripReceiver(@NotNull Call variableCall) {
return new DelegatingCall(variableCall) {
@NotNull
@Override
public ReceiverDescriptor getExplicitReceiver() {
return ReceiverDescriptor.NO_RECEIVER;
}
};
}
@NotNull
@Override
public Collection<ResolvedCallWithTrace<FunctionDescriptor>> transformCall(@NotNull final CallResolutionContext<CallableDescriptor, FunctionDescriptor> context,
@NotNull CallResolver callResolver, @NotNull final ResolutionTask<CallableDescriptor, FunctionDescriptor> task) {
final CallableDescriptor descriptor = context.candidateCall.getCandidateDescriptor();
if (descriptor instanceof FunctionDescriptor) {
return super.transformCall(context, callResolver, task);
}
assert descriptor instanceof VariableDescriptor;
JetType returnType = descriptor.getReturnType();
if (returnType == null) {
return Collections.emptyList();
}
final ResolvedCallWithTrace<VariableDescriptor> variableResolvedCall = (ResolvedCallWithTrace)context.candidateCall;
Call functionCall = createFunctionCall(context, task, returnType);
final TemporaryBindingTrace variableCallTrace = context.candidateCall.getTrace();
BasicResolutionContext basicResolutionContext = BasicResolutionContext.create(variableCallTrace, context.scope, functionCall, context.expectedType, context.dataFlowInfo);
// 'invoke' call resolve
OverloadResolutionResults<FunctionDescriptor> results = callResolver.resolveCallWithGivenName(basicResolutionContext, task.reference, "invoke");
Collection<ResolvedCallWithTrace<FunctionDescriptor>> calls = ((OverloadResolutionResultsImpl<FunctionDescriptor>)results).getResultingCalls();
return Collections2.transform(calls, new Function<ResolvedCallWithTrace<FunctionDescriptor>, ResolvedCallWithTrace<FunctionDescriptor>>() {
@Override
public ResolvedCallWithTrace<FunctionDescriptor> apply(ResolvedCallWithTrace<FunctionDescriptor> functionResolvedCall) {
return new VariableAsFunctionResolvedCall(functionResolvedCall, variableResolvedCall);
}
});
}
private Call createFunctionCall(final CallResolutionContext<CallableDescriptor, FunctionDescriptor> context,
final ResolutionTask<CallableDescriptor, FunctionDescriptor> task, JetType returnType) {
final ExpressionReceiver receiverFromVariable = new ExpressionReceiver(task.reference, returnType);
final JetSimpleNameExpression invokeExpression = (JetSimpleNameExpression) JetPsiFactory.createExpression(
task.call.getCallElement().getProject(), "invoke");
return new CallForImplicitInvoke(task.call) {
@NotNull
@Override
public ReceiverDescriptor getExplicitReceiver() {
return context.receiverForVariableAsFunctionSecondCall;
}
@NotNull
@Override
public ReceiverDescriptor getThisObject() {
return receiverFromVariable;
}
@Override
public JetExpression getCalleeExpression() {
return invokeExpression;
}
@NotNull
@Override
public PsiElement getCallElement() {
if (task.call.getCallElement() instanceof JetCallElement) {
//to report errors properly
JetValueArgumentList list = ((JetCallElement)task.call.getCallElement()).getValueArgumentList();
if (list != null) {
return list;
}
}
return invokeExpression;
}
};
}
};
public static class CallForImplicitInvoke extends DelegatingCall {
public CallForImplicitInvoke(@NotNull Call delegate) {
super(delegate);
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizer.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollector.java
+2 -2
View File
@@ -26,7 +26,7 @@ import java.util.Collection;
/**
* @author svtk
*/
public interface MemberPrioritizer<D extends CallableDescriptor> {
public interface CallableDescriptorCollector<D extends CallableDescriptor> {
@NotNull
Collection<D> getNonExtensionsByName(JetScope scope, String name);
@@ -34,5 +34,5 @@ public interface MemberPrioritizer<D extends CallableDescriptor> {
Collection<D> getMembersByName(@NotNull JetType receiver, String name);
@NotNull
Collection<D> getExtensionsByName(JetScope scope, String name);
Collection<D> getNonMembersByName(JetScope scope, String name);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/MemberPrioritizers.java → compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallableDescriptorCollectors.java
+23 -47
View File
@@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetType;
import java.util.*;
@@ -34,11 +33,9 @@ import java.util.*;
/**
* @author abreslav
*/
public class MemberPrioritizers {
/*package*/ static MemberPrioritizer<FunctionDescriptor> FUNCTION_TASK_PRIORITIZER = new MemberPrioritizer<FunctionDescriptor>() {
public class CallableDescriptorCollectors {
/*package*/ static CallableDescriptorCollector<FunctionDescriptor> FUNCTIONS = new CallableDescriptorCollector<FunctionDescriptor>() {
@NotNull
@Override
@@ -51,8 +48,6 @@ public class MemberPrioritizers {
}
}
addConstructors(scope, name, functions);
addVariableAsFunction(scope, name, functions, false);
return functions;
}
@@ -62,22 +57,13 @@ public class MemberPrioritizers {
JetScope receiverScope = receiverType.getMemberScope();
Set<FunctionDescriptor> members = Sets.newHashSet(receiverScope.getFunctions(name));
addConstructors(receiverScope, name, members);
addVariableAsFunction(receiverScope, name, members, false);
return members;
}
@NotNull
@Override
public Collection<FunctionDescriptor> getExtensionsByName(JetScope scope, String name) {
Set<FunctionDescriptor> extensionFunctions = Sets.newHashSet(scope.getFunctions(name));
for (Iterator<FunctionDescriptor> iterator = extensionFunctions.iterator(); iterator.hasNext(); ) {
FunctionDescriptor descriptor = iterator.next();
if (!descriptor.getReceiverParameter().exists()) {
iterator.remove();
}
}
addVariableAsFunction(scope, name, extensionFunctions, true);
return extensionFunctions;
public Collection<FunctionDescriptor> getNonMembersByName(JetScope scope, String name) {
return scope.getFunctions(name);
}
private void addConstructors(JetScope scope, String name, Collection<FunctionDescriptor> functions) {
@@ -87,25 +73,9 @@ public class MemberPrioritizers {
functions.addAll(classDescriptor.getConstructors());
}
}
private void addVariableAsFunction(JetScope scope, String name, Set<FunctionDescriptor> functions, boolean receiverNeeded) {
VariableDescriptor variable = scope.getLocalVariable(name);
if (variable == null) {
variable = DescriptorUtils.filterNonExtensionProperty(scope.getProperties(name));
}
if (variable != null) {
JetType outType = variable.getType();
if (outType != null && JetStandardClasses.isFunctionType(outType)) {
VariableAsFunctionDescriptor functionDescriptor = VariableAsFunctionDescriptor.create(variable);
if ((functionDescriptor.getReceiverParameter().exists()) == receiverNeeded) {
functions.add(functionDescriptor);
}
}
}
}
};
/*package*/ static MemberPrioritizer<VariableDescriptor> VARIABLE_TASK_PRIORITIZER = new MemberPrioritizer<VariableDescriptor>() {
/*package*/ static CallableDescriptorCollector<VariableDescriptor> VARIABLES = new CallableDescriptorCollector<VariableDescriptor>() {
@NotNull
@Override
@@ -126,17 +96,19 @@ public class MemberPrioritizers {
@NotNull
@Override
public Collection<VariableDescriptor> getExtensionsByName(JetScope scope, String name) {
return Collections2.filter(scope.getProperties(name), new Predicate<VariableDescriptor>() {
@Override
public boolean apply(@Nullable VariableDescriptor variableDescriptor) {
return (variableDescriptor != null) && variableDescriptor.getReceiverParameter().exists();
}
});
public Collection<VariableDescriptor> getNonMembersByName(JetScope scope, String name) {
Collection<VariableDescriptor> result = Sets.newLinkedHashSet();
VariableDescriptor localVariable = scope.getLocalVariable(name);
if (localVariable != null) {
result.add(localVariable);
}
result.addAll(scope.getProperties(name));
return result;
}
};
/*package*/ static MemberPrioritizer<VariableDescriptor> PROPERTY_TASK_PRIORITIZER = new MemberPrioritizer<VariableDescriptor>() {
/*package*/ static CallableDescriptorCollector<VariableDescriptor> PROPERTIES = new CallableDescriptorCollector<VariableDescriptor>() {
private Collection<VariableDescriptor> filterProperties(Collection<? extends VariableDescriptor> variableDescriptors) {
ArrayList<VariableDescriptor> properties = Lists.newArrayList();
for (VariableDescriptor descriptor : variableDescriptors) {
@@ -150,19 +122,23 @@ public class MemberPrioritizers {
@NotNull
@Override
public Collection<VariableDescriptor> getNonExtensionsByName(JetScope scope, String name) {
return filterProperties(VARIABLE_TASK_PRIORITIZER.getNonExtensionsByName(scope, name));
return filterProperties(VARIABLES.getNonExtensionsByName(scope, name));
}
@NotNull
@Override
public Collection<VariableDescriptor> getMembersByName(@NotNull JetType receiver, String name) {
return filterProperties(VARIABLE_TASK_PRIORITIZER.getMembersByName(receiver, name));
return filterProperties(VARIABLES.getMembersByName(receiver, name));
}
@NotNull
@Override
public Collection<VariableDescriptor> getExtensionsByName(JetScope scope, String name) {
return filterProperties(VARIABLE_TASK_PRIORITIZER.getExtensionsByName(scope, name));
public Collection<VariableDescriptor> getNonMembersByName(JetScope scope, String name) {
return filterProperties(VARIABLES.getNonMembersByName(scope, name));
}
};
/*package*/ static List<CallableDescriptorCollector<? extends CallableDescriptor>> FUNCTIONS_AND_VARIABLES = Lists.newArrayList(
FUNCTIONS, VARIABLES);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/DelegatingCall.java
+6
View File
@@ -48,6 +48,12 @@ public class DelegatingCall implements Call {
return delegate.getExplicitReceiver();
}
@NotNull
@Override
public ReceiverDescriptor getThisObject() {
return delegate.getThisObject();
}
@Override
@Nullable
public JetExpression getCalleeExpression() {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ExplicitReceiverKind.java
+39
View File
@@ -0,0 +1,39 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.calls;
/**
* @author svtk
*/
public enum ExplicitReceiverKind {
RECEIVER_ARGUMENT,
THIS_OBJECT,
NO_EXPLICIT_RECEIVER,
// A very special case.
// In a call 'b.foo(1)' where class 'Foo' has an extension member 'fun B.invoke(Int)' function 'invoke' has two explicit receivers:
// 'b' (as receiver argument) and 'foo' (as this object).
BOTH_RECEIVERS;
public boolean isReceiver() {
return this == RECEIVER_ARGUMENT || this == BOTH_RECEIVERS;
}
public boolean isThisObject() {
return this == THIS_OBJECT || this == BOTH_RECEIVERS;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java
+9 -9
View File
@@ -27,42 +27,42 @@ import java.util.Collections;
*/
/*package*/ class OverloadResolutionResultsImpl<D extends CallableDescriptor> implements OverloadResolutionResults<D> {
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> success(@NotNull ResolvedCallImpl<D> descriptor) {
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> success(@NotNull ResolvedCallWithTrace<D> descriptor) {
return new OverloadResolutionResultsImpl<D>(Code.SUCCESS, Collections.singleton(descriptor));
}
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> nameNotFound() {
return new OverloadResolutionResultsImpl<D>(Code.NAME_NOT_FOUND, Collections.<ResolvedCallImpl<D>>emptyList());
return new OverloadResolutionResultsImpl<D>(Code.NAME_NOT_FOUND, Collections.<ResolvedCallWithTrace<D>>emptyList());
}
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> singleFailedCandidate(ResolvedCallImpl<D> candidate) {
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> singleFailedCandidate(ResolvedCallWithTrace<D> candidate) {
return new OverloadResolutionResultsImpl<D>(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate));
}
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> manyFailedCandidates(Collection<ResolvedCallImpl<D>> failedCandidates) {
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> manyFailedCandidates(Collection<ResolvedCallWithTrace<D>> failedCandidates) {
return new OverloadResolutionResultsImpl<D>(Code.MANY_FAILED_CANDIDATES, failedCandidates);
}
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> ambiguity(Collection<ResolvedCallImpl<D>> descriptors) {
public static <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> ambiguity(Collection<ResolvedCallWithTrace<D>> descriptors) {
return new OverloadResolutionResultsImpl<D>(Code.AMBIGUITY, descriptors);
}
private final Collection<ResolvedCallImpl<D>> results;
private final Collection<ResolvedCallWithTrace<D>> results;
private final Code resultCode;
private OverloadResolutionResultsImpl(@NotNull Code resultCode, @NotNull Collection<ResolvedCallImpl<D>> results) {
private OverloadResolutionResultsImpl(@NotNull Code resultCode, @NotNull Collection<ResolvedCallWithTrace<D>> results) {
this.results = results;
this.resultCode = resultCode;
}
@Override
@NotNull
public Collection<ResolvedCallImpl<D>> getResultingCalls() {
public Collection<ResolvedCallWithTrace<D>> getResultingCalls() {
return results;
}
@Override
@NotNull
public ResolvedCallImpl<D> getResultingCall() {
public ResolvedCallWithTrace<D> getResultingCall() {
assert isSingleResult();
return results.iterator().next();
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsUtil.java
+3 -3
View File
@@ -30,9 +30,9 @@ import java.util.Collection;
public class OverloadResolutionResultsUtil {
@NotNull
public static <D extends CallableDescriptor> OverloadResolutionResults<D> ambiguity(OverloadResolutionResults<D> results1, OverloadResolutionResults<D> results2) {
Collection<ResolvedCallImpl<D>> resultingCalls = Lists.newArrayList();
resultingCalls.addAll((Collection<ResolvedCallImpl<D>>) results1.getResultingCalls());
resultingCalls.addAll((Collection<ResolvedCallImpl<D>>) results2.getResultingCalls());
Collection<ResolvedCallWithTrace<D>> resultingCalls = Lists.newArrayList();
resultingCalls.addAll((Collection<ResolvedCallWithTrace<D>>) results1.getResultingCalls());
resultingCalls.addAll((Collection<ResolvedCallWithTrace<D>>) results2.getResultingCalls());
return OverloadResolutionResultsImpl.ambiguity(resultingCalls);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java
+7 -7
View File
@@ -39,23 +39,23 @@ import java.util.Set;
public class OverloadingConflictResolver {
@Nullable
public <D extends CallableDescriptor> ResolvedCallImpl<D> findMaximallySpecific(Set<ResolvedCallImpl<D>> candidates, boolean discriminateGenericDescriptors) {
public <D extends CallableDescriptor> ResolvedCallWithTrace<D> findMaximallySpecific(Set<ResolvedCallWithTrace<D>> candidates, boolean discriminateGenericDescriptors) {
// Different autocasts may lead to the same candidate descriptor wrapped into different ResolvedCallImpl objects
Set<ResolvedCallImpl<D>> maximallySpecific = new THashSet<ResolvedCallImpl<D>>(new TObjectHashingStrategy<ResolvedCallImpl<D>>() {
Set<ResolvedCallWithTrace<D>> maximallySpecific = new THashSet<ResolvedCallWithTrace<D>>(new TObjectHashingStrategy<ResolvedCallWithTrace<D>>() {
@Override
public boolean equals(ResolvedCallImpl<D> o1, ResolvedCallImpl<D> o2) {
public boolean equals(ResolvedCallWithTrace<D> o1, ResolvedCallWithTrace<D> o2) {
return o1 == null ? o2 == null : o1.getResultingDescriptor().equals(o2.getResultingDescriptor());
}
@Override
public int computeHashCode(ResolvedCallImpl<D> object) {
public int computeHashCode(ResolvedCallWithTrace<D> object) {
return object == null ? 0 : object.getResultingDescriptor().hashCode();
}
});
meLoop:
for (ResolvedCallImpl<D> candidateCall : candidates) {
for (ResolvedCallWithTrace<D> candidateCall : candidates) {
D me = candidateCall.getResultingDescriptor();
for (ResolvedCallImpl<D> otherCall : candidates) {
for (ResolvedCallWithTrace<D> otherCall : candidates) {
D other = otherCall.getResultingDescriptor();
if (other == me) continue;
if (!moreSpecific(me, other, discriminateGenericDescriptors) || moreSpecific(other, me, discriminateGenericDescriptors)) {
@@ -65,7 +65,7 @@ public class OverloadingConflictResolver {
maximallySpecific.add(candidateCall);
}
if (maximallySpecific.size() == 1) {
ResolvedCallImpl<D> result = maximallySpecific.iterator().next();
ResolvedCallWithTrace<D> result = maximallySpecific.iterator().next();
result.getTrace().commit();
return result;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionCandidate.java
+48 -10
View File
@@ -18,12 +18,16 @@ package org.jetbrains.jet.lang.resolve.calls;
import com.google.common.collect.Lists;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.psi.Call;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.Collection;
import java.util.List;
import static org.jetbrains.jet.lang.resolve.calls.ExplicitReceiverKind.NO_EXPLICIT_RECEIVER;
import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER;
/**
@@ -31,15 +35,31 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
*/
public class ResolutionCandidate<D extends CallableDescriptor> {
private final D candidateDescriptor;
private ReceiverDescriptor thisObject = NO_RECEIVER; // receiver object of a method
private ReceiverDescriptor receiverArgument = NO_RECEIVER; // receiver of an extension function
private ReceiverDescriptor thisObject; // receiver object of a method
private ReceiverDescriptor receiverArgument; // receiver of an extension function
private ExplicitReceiverKind explicitReceiverKind;
private Boolean isSafeCall;
private ResolutionCandidate(@NotNull D descriptor) {
candidateDescriptor = descriptor;
private ResolutionCandidate(@NotNull D descriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument,
@NotNull ExplicitReceiverKind explicitReceiverKind, @Nullable Boolean isSafeCall) {
this.candidateDescriptor = descriptor;
this.thisObject = thisObject;
this.receiverArgument = receiverArgument;
this.explicitReceiverKind = explicitReceiverKind;
this.isSafeCall = isSafeCall;
}
public static <D extends CallableDescriptor> ResolutionCandidate<D> create(@NotNull D descriptor) {
return new ResolutionCandidate<D>(descriptor);
/*package*/ static <D extends CallableDescriptor> ResolutionCandidate<D> create(@NotNull D descriptor) {
return new ResolutionCandidate<D>(descriptor, NO_RECEIVER, NO_RECEIVER, NO_EXPLICIT_RECEIVER, null);
}
public static <D extends CallableDescriptor> ResolutionCandidate<D> create(@NotNull D descriptor, boolean isSafeCall) {
return create(descriptor, NO_RECEIVER, NO_RECEIVER, NO_EXPLICIT_RECEIVER, isSafeCall);
}
public static <D extends CallableDescriptor> ResolutionCandidate<D> create(@NotNull D descriptor, @NotNull ReceiverDescriptor thisObject,
@NotNull ReceiverDescriptor receiverArgument, @NotNull ExplicitReceiverKind explicitReceiverKind, boolean isSafeCall) {
return new ResolutionCandidate<D>(descriptor, thisObject, receiverArgument, explicitReceiverKind, isSafeCall);
}
public void setThisObject(@NotNull ReceiverDescriptor thisObject) {
@@ -50,6 +70,10 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
this.receiverArgument = receiverArgument;
}
public void setExplicitReceiverKind(@NotNull ExplicitReceiverKind explicitReceiverKind) {
this.explicitReceiverKind = explicitReceiverKind;
}
@NotNull
public D getDescriptor() {
return candidateDescriptor;
@@ -64,14 +88,28 @@ public class ResolutionCandidate<D extends CallableDescriptor> {
public ReceiverDescriptor getReceiverArgument() {
return receiverArgument;
}
@NotNull
public static <D extends CallableDescriptor> List<ResolutionCandidate<D>> convertCollection(@NotNull Collection<? extends D> descriptors) {
public ExplicitReceiverKind getExplicitReceiverKind() {
return explicitReceiverKind;
}
@NotNull
public static <D extends CallableDescriptor> List<ResolutionCandidate<D>> convertCollection(@NotNull Collection<? extends D> descriptors, boolean isSafeCall) {
List<ResolutionCandidate<D>> result = Lists.newArrayList();
for (D descriptor : descriptors) {
result.add(create(descriptor));
result.add(create(descriptor, isSafeCall));
}
return result;
}
public void setSafeCall(boolean safeCall) {
assert isSafeCall == null;
isSafeCall = safeCall;
}
public boolean isSafeCall() {
assert isSafeCall != null;
return isSafeCall;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionDebugInfo.java
+1 -1
View File
@@ -34,7 +34,7 @@ import java.util.Map;
* @author abreslav
*/
public class ResolutionDebugInfo {
public static final WritableSlice<One, List<? extends ResolutionTask<? extends CallableDescriptor>>> TASKS = Slices.createSimpleSlice();
public static final WritableSlice<One, List<? extends ResolutionTask<? extends CallableDescriptor, ?>>> TASKS = Slices.createSimpleSlice();
public static final WritableSlice<One, ResolvedCall<? extends CallableDescriptor>> RESULT = Slices.createSimpleSlice();
public static final WritableSlice<ResolvedCall<? extends CallableDescriptor>, StringBuilder> ERRORS = Slices.createSimpleSlice();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java
+28 -26
View File
@@ -16,8 +16,6 @@
package org.jetbrains.jet.lang.resolve.calls;
import com.google.common.collect.LinkedHashMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
@@ -39,6 +37,7 @@ import org.jetbrains.jet.lexer.JetTokens;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import static org.jetbrains.jet.lang.diagnostics.Errors.*;
import static org.jetbrains.jet.lang.resolve.BindingContext.*;
@@ -48,9 +47,9 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.*;
*
* @author abreslav
*/
public class ResolutionTask<D extends CallableDescriptor> extends ResolutionContext {
public class ResolutionTask<D extends CallableDescriptor, F extends D> extends ResolutionContext {
private final Collection<ResolutionCandidate<D>> candidates;
private final Multimap<ResolutionCandidate<D>, ResolvedCallImpl<D>> resolvedCallMap = LinkedHashMultimap.create();
private final Set<ResolvedCallWithTrace<F>> resolvedCalls = Sets.newLinkedHashSet();
/*package*/ final JetReferenceExpression reference;
private DescriptorCheckStrategy checkingStrategy;
@@ -71,8 +70,8 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
}
@NotNull
public Multimap<ResolutionCandidate<D>, ResolvedCallImpl<D>> getResolvedCallMap() {
return resolvedCallMap;
public Set<ResolvedCallWithTrace<F>> getResolvedCalls() {
return resolvedCalls;
}
public void setCheckingStrategy(DescriptorCheckStrategy strategy) {
@@ -86,8 +85,8 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
return true;
}
public ResolutionTask<D> withTrace(BindingTrace newTrace) {
ResolutionTask<D> newTask = new ResolutionTask<D>(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo);
public ResolutionTask<D, F> withTrace(BindingTrace newTrace) {
ResolutionTask<D, F> newTask = new ResolutionTask<D, F>(candidates, reference, newTrace, scope, call, expectedType, dataFlowInfo);
newTask.setCheckingStrategy(checkingStrategy);
return newTask;
}
@@ -98,22 +97,19 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
public final TracingStrategy tracing = new TracingStrategy() {
@Override
public <D extends CallableDescriptor> void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl<D> resolvedCall) {
D descriptor = resolvedCall.getCandidateDescriptor();
// if (descriptor instanceof VariableAsFunctionDescriptor) {
// VariableAsFunctionDescriptor variableAsFunctionDescriptor = (VariableAsFunctionDescriptor) descriptor;
// trace.record(REFERENCE_TARGET, reference, variableAsFunctionDescriptor.getVariableDescriptor());
// }
// else {
// }
trace.record(RESOLVED_CALL, call.getCalleeExpression(), resolvedCall);
public <D extends CallableDescriptor> void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace<D> resolvedCall) {
CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
if (resolvedCall instanceof VariableAsFunctionResolvedCall) {
descriptor = ((VariableAsFunctionResolvedCall) resolvedCall).getVariableCall().getResultingDescriptor();
}
trace.record(REFERENCE_TARGET, reference, descriptor);
trace.record(RESOLVED_CALL, call.getCalleeExpression(), resolvedCall);
}
@Override
public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallImpl<D>> candidates) {
public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallWithTrace<D>> candidates) {
Collection<D> descriptors = Sets.newHashSet();
for (ResolvedCallImpl<D> candidate : candidates) {
for (ResolvedCallWithTrace<D> candidate : candidates) {
descriptors.add(candidate.getCandidateDescriptor());
}
trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, descriptors);
@@ -155,7 +151,14 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
@Override
public void noReceiverAllowed(@NotNull BindingTrace trace) {
trace.report(NO_RECEIVER_ADMITTED.on(reference));
if (reference instanceof JetSimpleNameExpression) {
//todo temporary hack
//should be stored that the reference is unresolved (and not trace the candidate descriptor)
trace.report(UNRESOLVED_REFERENCE.on(reference));
}
else {
trace.report(NO_RECEIVER_ADMITTED.on(reference));
}
}
@Override
@@ -170,12 +173,12 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
}
@Override
public <D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors) {
public <D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors) {
trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallElement(), descriptors));
}
@Override
public <D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors) {
public <D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors) {
trace.report(NONE_APPLICABLE.on(reference, descriptors));
}
@@ -191,9 +194,9 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
}
@Override
public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type) {
public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type, boolean isCallForImplicitInvoke) {
ASTNode callOperationNode = call.getCallOperationNode();
if (callOperationNode != null) {
if (callOperationNode != null && !isCallForImplicitInvoke) {
trace.report(UNSAFE_CALL.on(callOperationNode.getPsi(), type));
}
else {
@@ -233,8 +236,7 @@ public class ResolutionTask<D extends CallableDescriptor> extends ResolutionCont
@Override
public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor) {
JetExpression expression = call.getCalleeExpression();
trace.report(INVISIBLE_MEMBER.on(expression != null ? expression : call.getCallElement(), descriptor, descriptor.getContainingDeclaration()));
trace.report(INVISIBLE_MEMBER.on(call.getCallElement(), descriptor, descriptor.getContainingDeclaration()));
}
};
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTaskHolder.java
+19 -7
View File
@@ -21,9 +21,12 @@ import com.google.common.base.Predicates;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.intellij.lang.ASTNode;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.lang.psi.JetReferenceExpression;
import org.jetbrains.jet.lexer.JetTokens;
import java.util.Collection;
import java.util.List;
@@ -31,16 +34,17 @@ import java.util.List;
/**
* @author svtk
*/
public class ResolutionTaskHolder<D extends CallableDescriptor> {
public class ResolutionTaskHolder<D extends CallableDescriptor, F extends D> {
private final JetReferenceExpression reference;
private final BasicResolutionContext basicResolutionContext;
private final Predicate<ResolutionCandidate<D>> visibleStrategy;
private final boolean isSafeCall;
private final Collection<Collection<ResolutionCandidate<D>>> localExtensions = Sets.newLinkedHashSet();
private final Collection<Collection<ResolutionCandidate<D>>> members = Sets.newLinkedHashSet();
private final Collection<Collection<ResolutionCandidate<D>>> nonLocalExtensions = Sets.newLinkedHashSet();
private List<ResolutionTask<D>> tasks = null;
private List<ResolutionTask<D, F>> tasks = null;
public ResolutionTaskHolder(@NotNull JetReferenceExpression reference,
@NotNull BasicResolutionContext basicResolutionContext,
@@ -48,27 +52,35 @@ public class ResolutionTaskHolder<D extends CallableDescriptor> {
this.reference = reference;
this.basicResolutionContext = basicResolutionContext;
this.visibleStrategy = visibleStrategy;
this.isSafeCall = JetPsiUtil.isSafeCall(basicResolutionContext.call);
}
public Collection<ResolutionCandidate<D>> setIsSafeCall(@NotNull Collection<ResolutionCandidate<D>> candidates) {
for (ResolutionCandidate<D> candidate : candidates) {
candidate.setSafeCall(isSafeCall);
}
return candidates;
}
public void addLocalExtensions(@NotNull Collection<ResolutionCandidate<D>> candidates) {
if (!candidates.isEmpty()) {
localExtensions.add(candidates);
localExtensions.add(setIsSafeCall(candidates));
}
}
public void addMembers(@NotNull Collection<ResolutionCandidate<D>> candidates) {
if (!candidates.isEmpty()) {
members.add(candidates);
members.add(setIsSafeCall(candidates));
}
}
public void addNonLocalExtensions(@NotNull Collection<ResolutionCandidate<D>> candidates) {
if (!candidates.isEmpty()) {
nonLocalExtensions.add(candidates);
nonLocalExtensions.add(setIsSafeCall(candidates));
}
}
public List<ResolutionTask<D>> getTasks() {
public List<ResolutionTask<D, F>> getTasks() {
if (tasks == null) {
tasks = Lists.newArrayList();
List<Collection<ResolutionCandidate<D>>> candidateList = Lists.newArrayList();
@@ -89,7 +101,7 @@ public class ResolutionTaskHolder<D extends CallableDescriptor> {
for (Collection<ResolutionCandidate<D>> candidates : candidateList) {
Collection<ResolutionCandidate<D>> filteredCandidates = Collections2.filter(candidates, visibilityStrategy);
if (!filteredCandidates.isEmpty()) {
tasks.add(new ResolutionTask<D>(filteredCandidates, reference, basicResolutionContext));
tasks.add(new ResolutionTask<D, F>(filteredCandidates, reference, basicResolutionContext));
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java
+6
View File
@@ -46,6 +46,10 @@ public interface ResolvedCall<D extends CallableDescriptor> {
@NotNull
ReceiverDescriptor getThisObject();
/** Determines whether receiver argument or this object is substituted for explicit receiver */
@NotNull
ExplicitReceiverKind getExplicitReceiverKind();
/** Values (arguments) for value parameters */
@NotNull
Map<ValueParameterDescriptor, ResolvedValueArgument> getValueArguments();
@@ -57,4 +61,6 @@ public interface ResolvedCall<D extends CallableDescriptor> {
/** What's substituted for type parameters */
@NotNull
Map<TypeParameterDescriptor, JetType> getTypeArguments();
boolean isSafeCall();
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java
+30 -17
View File
@@ -16,7 +16,6 @@
package org.jetbrains.jet.lang.resolve.calls;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.intellij.util.Function;
import org.jetbrains.annotations.NotNull;
@@ -28,7 +27,6 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
@@ -37,31 +35,33 @@ import static org.jetbrains.jet.lang.resolve.calls.ResolutionStatus.UNKNOWN_STAT
/**
* @author abreslav
*/
public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedCall<D> {
public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedCallWithTrace<D> {
public static final Function<ResolvedCallImpl<? extends CallableDescriptor>, CallableDescriptor> MAP_TO_CANDIDATE = new Function<ResolvedCallImpl<? extends CallableDescriptor>, CallableDescriptor>() {
public static final Function<ResolvedCallWithTrace<? extends CallableDescriptor>, CallableDescriptor> MAP_TO_CANDIDATE = new Function<ResolvedCallWithTrace<? extends CallableDescriptor>, CallableDescriptor>() {
@Override
public CallableDescriptor fun(ResolvedCallImpl<? extends CallableDescriptor> resolvedCall) {
public CallableDescriptor fun(ResolvedCallWithTrace<? extends CallableDescriptor> resolvedCall) {
return resolvedCall.getCandidateDescriptor();
}
};
public static final Function<ResolvedCallImpl<? extends CallableDescriptor>, CallableDescriptor> MAP_TO_RESULT = new Function<ResolvedCallImpl<? extends CallableDescriptor>, CallableDescriptor>() {
public static final Function<ResolvedCallWithTrace<? extends CallableDescriptor>, CallableDescriptor> MAP_TO_RESULT = new Function<ResolvedCallWithTrace<? extends CallableDescriptor>, CallableDescriptor>() {
@Override
public CallableDescriptor fun(ResolvedCallImpl<? extends CallableDescriptor> resolvedCall) {
public CallableDescriptor fun(ResolvedCallWithTrace<? extends CallableDescriptor> resolvedCall) {
return resolvedCall.getResultingDescriptor();
}
};
@NotNull
public static <D extends CallableDescriptor> ResolvedCallImpl<D> create(@NotNull ResolutionCandidate<D> candidate) {
return new ResolvedCallImpl<D>(candidate.getDescriptor(), candidate.getThisObject(), candidate.getReceiverArgument());
public static <D extends CallableDescriptor> ResolvedCallImpl<D> create(@NotNull ResolutionCandidate<D> candidate, @NotNull TemporaryBindingTrace trace) {
return new ResolvedCallImpl<D>(candidate, trace);
}
private final D candidateDescriptor;
private D resultingDescriptor; // Probably substituted
private final ReceiverDescriptor thisObject; // receiver object of a method
private final ReceiverDescriptor receiverArgument; // receiver of an extension function
private final ExplicitReceiverKind explicitReceiverKind;
private final boolean isSafeCall;
private final Map<TypeParameterDescriptor, JetType> typeArguments = Maps.newLinkedHashMap();
private final Map<ValueParameterDescriptor, JetType> autoCasts = Maps.newHashMap();
@@ -70,12 +70,16 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
private TemporaryBindingTrace trace;
private ResolutionStatus status = UNKNOWN_STATUS;
private ResolvedCallImpl(@NotNull D candidateDescriptor, @NotNull ReceiverDescriptor thisObject, @NotNull ReceiverDescriptor receiverArgument) {
this.candidateDescriptor = candidateDescriptor;
this.thisObject = thisObject;
this.receiverArgument = receiverArgument;
private ResolvedCallImpl(@NotNull ResolutionCandidate<D> candidate, @NotNull TemporaryBindingTrace trace) {
this.candidateDescriptor = candidate.getDescriptor();
this.thisObject = candidate.getThisObject();
this.receiverArgument = candidate.getReceiverArgument();
this.explicitReceiverKind = candidate.getExplicitReceiverKind();
this.isSafeCall = candidate.isSafeCall();
this.trace = trace;
}
@Override
@NotNull
public ResolutionStatus getStatus() {
return status;
@@ -85,15 +89,12 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
this.status = this.status.combine(status);
}
@Override
@NotNull
public TemporaryBindingTrace getTrace() {
return trace;
}
public void setTrace(@NotNull TemporaryBindingTrace trace) {
this.trace = trace;
}
@Override
@NotNull
public D getCandidateDescriptor() {
@@ -138,6 +139,12 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
return thisObject;
}
@Override
@NotNull
public ExplicitReceiverKind getExplicitReceiverKind() {
return explicitReceiverKind;
}
@Override
@NotNull
public Map<ValueParameterDescriptor, ResolvedValueArgument> getValueArguments() {
@@ -171,6 +178,7 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
this.someArgumentHasNoType = true;
}
@Override
public boolean isDirty() {
return someArgumentHasNoType;
}
@@ -180,4 +188,9 @@ public class ResolvedCallImpl<D extends CallableDescriptor> implements ResolvedC
public Map<TypeParameterDescriptor, JetType> getTypeArguments() {
return typeArguments;
}
@Override
public boolean isSafeCall() {
return isSafeCall;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallWithTrace.java
+34
View File
@@ -0,0 +1,34 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.calls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
/**
* @author svtk
*/
public interface ResolvedCallWithTrace<D extends CallableDescriptor> extends ResolvedCall<D> {
@NotNull
ResolutionStatus getStatus();
boolean isDirty();
TemporaryBindingTrace getTrace();
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
+48 -33
View File
@@ -74,8 +74,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
}
@NotNull
public static <D extends CallableDescriptor> List<ResolutionTask<D>> computePrioritizedTasks(@NotNull BasicResolutionContext context, @NotNull String name,
@NotNull JetReferenceExpression functionReference, @NotNull List<MemberPrioritizer<D>> memberPrioritizers) {
public static <D extends CallableDescriptor, F extends D> List<ResolutionTask<D, F>> computePrioritizedTasks(@NotNull BasicResolutionContext context, @NotNull String name,
@NotNull JetReferenceExpression functionReference, @NotNull List<CallableDescriptorCollector<? extends D>> callableDescriptorCollectors) {
ReceiverDescriptor explicitReceiver = context.call.getExplicitReceiver();
final JetScope scope;
if (explicitReceiver.exists() && explicitReceiver.getType() instanceof NamespaceType) {
@@ -96,23 +96,27 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
}
};
ResolutionTaskHolder<D> result = new ResolutionTaskHolder<D>(functionReference, context, visibleStrategy );
doComputeTasks(scope, explicitReceiver, name, result, context, memberPrioritizers);
ResolutionTaskHolder<D, F> result = new ResolutionTaskHolder<D, F>(functionReference, context, visibleStrategy);
for (CallableDescriptorCollector<? extends D> callableDescriptorCollector : callableDescriptorCollectors) {
doComputeTasks(scope, explicitReceiver, name, result, context, callableDescriptorCollector);
}
return result.getTasks();
}
private static <D extends CallableDescriptor> void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver,
@NotNull String name, @NotNull ResolutionTaskHolder<D> result,
@NotNull BasicResolutionContext context, @NotNull List<MemberPrioritizer<D>> memberPrioritizers) {
MemberPrioritizer<D> memberPrioritizer = memberPrioritizers.get(0);
private static <D extends CallableDescriptor, F extends D> void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver,
@NotNull String name, @NotNull ResolutionTaskHolder<D, F> result,
@NotNull BasicResolutionContext context, @NotNull CallableDescriptorCollector<? extends D> callableDescriptorCollector) {
AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext());
List<ReceiverDescriptor> implicitReceivers = Lists.newArrayList();
scope.getImplicitReceiversHierarchy(implicitReceivers);
boolean hasExplicitThisObject = context.call.getThisObject().exists();
if (hasExplicitThisObject) {
implicitReceivers.add(context.call.getThisObject());
}
if (receiver.exists()) {
List<ReceiverDescriptor> variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver);
Collection<ResolutionCandidate<D>> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, memberPrioritizer.getExtensionsByName(scope, name));
Collection<ResolutionCandidate<D>> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(scope, name));
List<ResolutionCandidate<D>> nonlocals = Lists.newArrayList();
List<ResolutionCandidate<D>> locals = Lists.newArrayList();
//noinspection unchecked,RedundantTypeArguments
@@ -120,23 +124,25 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
Collection<ResolutionCandidate<D>> members = Lists.newArrayList();
for (ReceiverDescriptor variant : variantsForExplicitReceiver) {
Collection<D> membersForThisVariant = memberPrioritizer.getMembersByName(variant.getType(), name);
convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members);
Collection<? extends D> membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), name);
convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members, hasExplicitThisObject);
}
result.addLocalExtensions(locals);
result.addMembers(members);
for (ReceiverDescriptor implicitReceiver : implicitReceivers) {
Collection<D> memberExtensions = memberPrioritizer.getExtensionsByName(implicitReceiver.getType().getMemberScope(), name);
Collection<? extends D> memberExtensions = callableDescriptorCollector.getNonMembersByName(
implicitReceiver.getType().getMemberScope(), name);
List<ReceiverDescriptor> variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver);
result.addNonLocalExtensions(convertWithReceivers(memberExtensions, variantsForImplicitReceiver, variantsForExplicitReceiver));
result.addNonLocalExtensions(convertWithReceivers(memberExtensions, variantsForImplicitReceiver, variantsForExplicitReceiver, hasExplicitThisObject));
}
result.addNonLocalExtensions(nonlocals);
}
else {
Collection<ResolutionCandidate<D>> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), memberPrioritizer.getNonExtensionsByName(scope, name));
Collection<ResolutionCandidate<D>> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), callableDescriptorCollector
.getNonExtensionsByName(scope, name));
List<ResolutionCandidate<D>> nonlocals = Lists.newArrayList();
List<ResolutionCandidate<D>> locals = Lists.newArrayList();
@@ -147,25 +153,31 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
result.addNonLocalExtensions(nonlocals);
for (ReceiverDescriptor implicitReceiver : implicitReceivers) {
doComputeTasks(scope, implicitReceiver, name, result, context, memberPrioritizers);
doComputeTasks(scope, implicitReceiver, name, result, context, callableDescriptorCollector);
}
}
}
private static <D extends CallableDescriptor> Collection<ResolutionCandidate<D>> convertWithReceivers(Collection<D> descriptors, Iterable<ReceiverDescriptor> thisObjects, Iterable<ReceiverDescriptor> receiverParameters) {
private static <D extends CallableDescriptor> Collection<ResolutionCandidate<D>> convertWithReceivers(Collection<? extends D> descriptors, Iterable<ReceiverDescriptor> thisObjects,
Iterable<ReceiverDescriptor> receiverParameters, boolean hasExplicitThisObject) {
Collection<ResolutionCandidate<D>> result = Lists.newArrayList();
convertWithReceivers(descriptors, thisObjects, receiverParameters, result);
convertWithReceivers(descriptors, thisObjects, receiverParameters, result, hasExplicitThisObject);
return result;
}
private static <D extends CallableDescriptor> void convertWithReceivers(Collection<D> descriptors, Iterable<ReceiverDescriptor> thisObjects, Iterable<ReceiverDescriptor> receiverParameters, Collection<ResolutionCandidate<D>> result) {
private static <D extends CallableDescriptor> void convertWithReceivers(Collection<? extends D> descriptors, Iterable<ReceiverDescriptor> thisObjects, Iterable<ReceiverDescriptor> receiverParameters,
Collection<ResolutionCandidate<D>> result, boolean hasExplicitThisObject) {
for (ReceiverDescriptor thisObject : thisObjects) {
for (ReceiverDescriptor receiverParameter : receiverParameters) {
for (D extension : descriptors) {
ResolutionCandidate<D> resolvedCall = ResolutionCandidate.create(extension);
resolvedCall.setThisObject(thisObject);
resolvedCall.setReceiverArgument(receiverParameter);
result.add(resolvedCall);
ResolutionCandidate<D> candidate = ResolutionCandidate.create(extension);
candidate.setThisObject(thisObject);
candidate.setReceiverArgument(receiverParameter);
candidate.setExplicitReceiverKind(
hasExplicitThisObject ? ExplicitReceiverKind.BOTH_RECEIVERS : ExplicitReceiverKind.THIS_OBJECT);
result.add(candidate);
}
}
}
@@ -175,10 +187,12 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
Collection<ResolutionCandidate<D>> result = Lists.newArrayList();
for (ReceiverDescriptor receiverParameter : receiverParameters) {
for (D descriptor : descriptors) {
ResolutionCandidate<D> resolvedCall = ResolutionCandidate.create(descriptor);
resolvedCall.setReceiverArgument(receiverParameter);
if (setImpliedThis(scope, resolvedCall)) {
result.add(resolvedCall);
ResolutionCandidate<D> candidate = ResolutionCandidate.create(descriptor);
candidate.setReceiverArgument(receiverParameter);
candidate.setExplicitReceiverKind(
receiverParameter.exists() ? ExplicitReceiverKind.RECEIVER_ARGUMENT : ExplicitReceiverKind.NO_EXPLICIT_RECEIVER);
if (setImpliedThis(scope, candidate)) {
result.add(candidate);
}
}
}
@@ -190,24 +204,25 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
containingDeclaration = containingDeclaration.getContainingDeclaration();
}
if (containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).getKind() == ClassKind.OBJECT) {
ResolutionCandidate<D> resolvedCall = ResolutionCandidate.create(descriptor);
resolvedCall.setThisObject(new ClassReceiver((ClassDescriptor) containingDeclaration));
result.add(resolvedCall);
ResolutionCandidate<D> candidate = ResolutionCandidate.create(descriptor);
candidate.setThisObject(new ClassReceiver((ClassDescriptor) containingDeclaration));
candidate.setExplicitReceiverKind(ExplicitReceiverKind.NO_EXPLICIT_RECEIVER);
result.add(candidate);
}
}
}
return result;
}
private static <D extends CallableDescriptor> boolean setImpliedThis(@NotNull JetScope scope, ResolutionCandidate<D> resolvedCall) {
ReceiverDescriptor expectedThisObject = resolvedCall.getDescriptor().getExpectedThisObject();
private static <D extends CallableDescriptor> boolean setImpliedThis(@NotNull JetScope scope, ResolutionCandidate<D> candidate) {
ReceiverDescriptor expectedThisObject = candidate.getDescriptor().getExpectedThisObject();
if (!expectedThisObject.exists()) return true;
List<ReceiverDescriptor> receivers = Lists.newArrayList();
scope.getImplicitReceiversHierarchy(receivers);
for (ReceiverDescriptor receiver : receivers) {
if (JetTypeChecker.INSTANCE.isSubtypeOf(receiver.getType(), expectedThisObject.getType())) {
// TODO : Autocasts & nullability
resolvedCall.setThisObject(expectedThisObject);
candidate.setThisObject(expectedThisObject);
return true;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java
+11 -10
View File
@@ -34,14 +34,15 @@ import java.util.List;
*/
/*package*/ interface TracingStrategy {
TracingStrategy EMPTY = new TracingStrategy() {
@Override
public <D extends CallableDescriptor> void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl<D> resolvedCall) {}
public <D extends CallableDescriptor> void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace<D> resolvedCall) {}
@Override
public void unresolvedReference(@NotNull BindingTrace trace) {}
@Override
public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallImpl<D>> candidates) {}
public <D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallWithTrace<D>> candidates) {}
@Override
public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) {}
@@ -59,10 +60,10 @@ import java.util.List;
public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {}
@Override
public <D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors) {}
public <D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors) {}
@Override
public <D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors) {}
public <D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors) {}
@Override
public void instantiationOfAbstractClass(@NotNull BindingTrace trace) {}
@@ -71,7 +72,7 @@ import java.util.List;
public void typeInferenceFailed(@NotNull BindingTrace trace, SolutionStatus status) {}
@Override
public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type) {}
public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type, boolean isCallForImplicitInvoke) {}
@Override
public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type) {}
@@ -83,11 +84,11 @@ import java.util.List;
public void invisibleMember(@NotNull BindingTrace trace, @NotNull DeclarationDescriptor descriptor) {}
};
<D extends CallableDescriptor> void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl<D> resolvedCall);
<D extends CallableDescriptor> void bindResolvedCall(@NotNull BindingTrace trace, @NotNull ResolvedCallWithTrace<D> resolvedCall);
void unresolvedReference(@NotNull BindingTrace trace);
<D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallImpl<D>> candidates);
<D extends CallableDescriptor> void recordAmbiguity(BindingTrace trace, Collection<ResolvedCallWithTrace<D>> candidates);
void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver);
@@ -99,15 +100,15 @@ import java.util.List;
void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount);
<D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors);
<D extends CallableDescriptor> void ambiguity(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors);
<D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallImpl<D>> descriptors);
<D extends CallableDescriptor> void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection<ResolvedCallWithTrace<D>> descriptors);
void instantiationOfAbstractClass(@NotNull BindingTrace trace);
void typeInferenceFailed(@NotNull BindingTrace trace, SolutionStatus status);
void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type);
void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type, boolean isCallForImplicitInvoke);
void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java
+1 -32
View File
@@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -80,9 +79,7 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
D candidate = candidateCall.getCandidateDescriptor();
D base = getDescriptorForValueArgumentsResolving(candidate);
List<ValueParameterDescriptor> valueParameters = base.getValueParameters();
List<ValueParameterDescriptor> valueParameters = candidate.getValueParameters();
Map<String, ValueParameterDescriptor> parameterByName = Maps.newHashMap();
for (ValueParameterDescriptor valueParameter : valueParameters) {
@@ -242,32 +239,4 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
}
return error;
}
/**
* Descriptor used to resolve parameter names and default parameter values.
*/
@NotNull
private static <D extends CallableDescriptor> D getDescriptorForValueArgumentsResolving(D descriptor) {
Set<D> allBases = new HashSet<D>();
getAllDescriptorsForValueArgumentsResolving(descriptor, allBases);
if (allBases.size() == 1) {
return allBases.iterator().next();
}
else {
// TODO remove parameter names and parameter default values
return descriptor;
}
}
private static <D extends CallableDescriptor> void getAllDescriptorsForValueArgumentsResolving(D descriptor, Set<D> dest) {
if (descriptor.getOverriddenDescriptors().isEmpty()) {
dest.add(descriptor);
}
else {
for (CallableDescriptor overriden : descriptor.getOverriddenDescriptors()) {
getAllDescriptorsForValueArgumentsResolving((D) overriden, dest);
}
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/VariableAsFunctionResolvedCall.java
+124
View File
@@ -0,0 +1,124 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.calls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import java.util.List;
import java.util.Map;
/**
* @author svtk
*/
public class VariableAsFunctionResolvedCall implements ResolvedCallWithTrace<FunctionDescriptor> {
private final ResolvedCallWithTrace<FunctionDescriptor> functionCall;
private final ResolvedCallWithTrace<VariableDescriptor> variableCall;
public VariableAsFunctionResolvedCall(@NotNull ResolvedCallWithTrace<FunctionDescriptor> functionCall,
@NotNull ResolvedCallWithTrace<VariableDescriptor> variableCall) {
this.functionCall = functionCall;
this.variableCall = variableCall;
}
public ResolvedCallWithTrace<FunctionDescriptor> getFunctionCall() {
return functionCall;
}
public ResolvedCallWithTrace<VariableDescriptor> getVariableCall() {
return variableCall;
}
@NotNull
@Override
public FunctionDescriptor getCandidateDescriptor() {
return functionCall.getResultingDescriptor();
}
@NotNull
@Override
public FunctionDescriptor getResultingDescriptor() {
return functionCall.getResultingDescriptor();
}
@NotNull
@Override
public ReceiverDescriptor getReceiverArgument() {
return variableCall.getReceiverArgument();
}
@NotNull
@Override
public ReceiverDescriptor getThisObject() {
return variableCall.getThisObject();
}
@NotNull
@Override
public ExplicitReceiverKind getExplicitReceiverKind() {
return variableCall.getExplicitReceiverKind();
}
@NotNull
@Override
public Map<ValueParameterDescriptor, ResolvedValueArgument> getValueArguments() {
return functionCall.getValueArguments();
}
@NotNull
@Override
public List<ResolvedValueArgument> getValueArgumentsByIndex() {
return functionCall.getValueArgumentsByIndex();
}
@NotNull
@Override
public Map<TypeParameterDescriptor, JetType> getTypeArguments() {
return functionCall.getTypeArguments();
}
@NotNull
@Override
public ResolutionStatus getStatus() {
if (variableCall.getStatus() == ResolutionStatus.SUCCESS) {
return functionCall.getStatus();
}
return variableCall.getStatus();
}
@Override
public boolean isDirty() {
return functionCall.isDirty();
}
@Override
public TemporaryBindingTrace getTrace() {
//functionCall.trace is temporary trace above variableCall.trace and is committed already
return variableCall.getTrace();
}
@Override
public boolean isSafeCall() {
return variableCall.isSafeCall();
}
}
compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java
+2 -1
View File
@@ -239,7 +239,8 @@ public class ErrorUtils {
public static boolean isErrorType(@NotNull JetType type) {
return type != TypeUtils.NO_EXPECTED_TYPE && !(type instanceof NamespaceType) &&
(
(type instanceof DeferredType && ((DeferredType) type).getActualType() == null) ||
(type instanceof DeferredType && (((DeferredType) type).getActualType() == null
|| isErrorType(((DeferredType) type).getActualType()))) ||
type instanceof ErrorTypeImpl ||
isError(type.getConstructor())
);
compiler/frontend/src/org/jetbrains/jet/lang/types/SubstitutionUtils.java
+138
View File
@@ -0,0 +1,138 @@
/*
* Copyright 2010-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.types;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.util.CommonSuppliers;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author abreslav
*/
public class SubstitutionUtils {
@NotNull
public static Map<TypeConstructor, TypeProjection> buildSubstitutionContext(@NotNull JetType context) {
return buildSubstitutionContext(context.getConstructor().getParameters(), context.getArguments());
}
/**
* Builds a context with all the supertypes' parameters substituted
*/
@NotNull
public static TypeSubstitutor buildDeepSubstitutor(@NotNull JetType type) {
Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
// we use the mutability of the map here
fillInDeepSubstitutor(type, typeSubstitutor, substitution, null);
return typeSubstitutor;
}
@NotNull
public static Multimap<TypeConstructor, TypeProjection> buildDeepSubstitutionMultimap(@NotNull JetType type) {
Multimap<TypeConstructor, TypeProjection> fullSubstitution = CommonSuppliers.newLinkedHashSetHashSetMultimap();
Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
// we use the mutability of the map here
fillInDeepSubstitutor(type, typeSubstitutor, substitution, fullSubstitution);
return fullSubstitution;
}
// we use the mutability of the substitution map here
private static void fillInDeepSubstitutor(@NotNull JetType context, @NotNull TypeSubstitutor substitutor, @NotNull Map<TypeConstructor, TypeProjection> substitution, @Nullable Multimap<TypeConstructor, TypeProjection> fullSubstitution) {
List<TypeParameterDescriptor> parameters = context.getConstructor().getParameters();
List<TypeProjection> arguments = context.getArguments();
if (parameters.size() != arguments.size()) {
throw new IllegalStateException();
}
for (int i = 0; i < arguments.size(); i++) {
TypeProjection argument = arguments.get(i);
TypeParameterDescriptor typeParameterDescriptor = parameters.get(i);
JetType substitute = substitutor.substitute(argument.getType(), Variance.INVARIANT);
assert substitute != null;
TypeProjection substitutedTypeProjection = new TypeProjection(argument.getProjectionKind(), substitute);
substitution.put(typeParameterDescriptor.getTypeConstructor(), substitutedTypeProjection);
if (fullSubstitution != null) {
fullSubstitution.put(typeParameterDescriptor.getTypeConstructor(), substitutedTypeProjection);
}
}
if (JetStandardClasses.isNothingOrNullableNothing(context)) return;
for (JetType supertype : context.getConstructor().getSupertypes()) {
fillInDeepSubstitutor(supertype, substitutor, substitution, fullSubstitution);
}
}
@NotNull
public static Map<TypeConstructor, TypeProjection> buildSubstitutionContext(@NotNull List<TypeParameterDescriptor> parameters, @NotNull List<TypeProjection> contextArguments) {
Map<TypeConstructor, TypeProjection> parameterValues = new HashMap<TypeConstructor, TypeProjection>();
fillInSubstitutionContext(parameters, contextArguments, parameterValues);
return parameterValues;
}
private static void fillInSubstitutionContext(List<TypeParameterDescriptor> parameters, List<TypeProjection> contextArguments, Map<TypeConstructor, TypeProjection> parameterValues) {
for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) {
TypeParameterDescriptor parameter = parameters.get(i);
TypeProjection value = contextArguments.get(i);
parameterValues.put(parameter.getTypeConstructor(), value);
}
}
@NotNull
public static TypeProjection makeStarProjection(@NotNull TypeParameterDescriptor parameterDescriptor) {
return new TypeProjection(Variance.OUT_VARIANCE, parameterDescriptor.getUpperBoundsAsType());
}
public static boolean hasUnsubstitutedTypeParameters(JetType type) {
if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
return true;
}
for(TypeProjection proj : type.getArguments()) {
if(hasUnsubstitutedTypeParameters(proj.getType())) {
return true;
}
}
return false;
}
public static void assertNotImmediatelyRecursive(Map<TypeConstructor, TypeProjection> context) {
// Make sure we never replace a T with "Foo<T>" or something similar,
// because the substitution will not terminate in this case
// This check is not complete. It does not find cases like
// T -> Foo<T1>
// T -> Bar<T>
for (Map.Entry<TypeConstructor, TypeProjection> entry : context.entrySet()) {
TypeConstructor key = entry.getKey();
TypeProjection value = entry.getValue();
if (TypeUtils.typeConstructorUsedInType(key, value.getType())) {
throw new IllegalStateException("Immediately recursive substitution: " + context + "\nProblematic parameter: " + key + " -> " + value);
}
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java
+2 -2
View File
@@ -127,7 +127,7 @@ public class TypeSubstitutor {
}
public static TypeSubstitutor create(@NotNull JetType context) {
return create(TypeUtils.buildSubstitutionContext(context));
return create(SubstitutionUtils.buildSubstitutionContext(context));
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -254,7 +254,7 @@ public class TypeSubstitutor {
assert typeToSubstituteIn.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor;
if (!allows(parameterVariance, passedProjectionKind)) {
return TypeUtils.makeStarProjection(correspondingTypeParameter);
return SubstitutionUtils.makeStarProjection(correspondingTypeParameter);
}
return substitutionResult(correspondingTypeParameter, effectiveContextVariance, passedProjectionKind, projectionValue, recursionDepth + 1);
compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java
+15 -91
View File
@@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.types;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import com.intellij.util.Processor;
import org.jetbrains.annotations.NotNull;
@@ -36,7 +35,6 @@ import org.jetbrains.jet.lang.resolve.scopes.ChainedScope;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
import org.jetbrains.jet.util.CommonSuppliers;
import java.util.*;
@@ -140,7 +138,9 @@ public class TypeUtils {
@Nullable
public static JetType intersect(@NotNull JetTypeChecker typeChecker, @NotNull Set<JetType> types) {
assert !types.isEmpty();
if (types.isEmpty()) {
return JetStandardClasses.getNullableAnyType();
}
if (types.size() == 1) {
return types.iterator().next();
@@ -399,80 +399,6 @@ public class TypeUtils {
return result;
}
@NotNull
public static Map<TypeConstructor, TypeProjection> buildSubstitutionContext(@NotNull JetType context) {
return buildSubstitutionContext(context.getConstructor().getParameters(), context.getArguments());
}
/**
* Builds a context with all the supertypes' parameters substituted
*/
@NotNull
public static TypeSubstitutor buildDeepSubstitutor(@NotNull JetType type) {
Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
// we use the mutability of the map here
fillInDeepSubstitutor(type, typeSubstitutor, substitution, null);
return typeSubstitutor;
}
@NotNull
public static Multimap<TypeConstructor, TypeProjection> buildDeepSubstitutionMultimap(@NotNull JetType type) {
Multimap<TypeConstructor, TypeProjection> fullSubstitution = CommonSuppliers.newLinkedHashSetHashSetMultimap();
Map<TypeConstructor, TypeProjection> substitution = Maps.newHashMap();
TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitution);
// we use the mutability of the map here
fillInDeepSubstitutor(type, typeSubstitutor, substitution, fullSubstitution);
return fullSubstitution;
}
// we use the mutability of the substitution map here
private static void fillInDeepSubstitutor(@NotNull JetType context, @NotNull TypeSubstitutor substitutor, @NotNull Map<TypeConstructor, TypeProjection> substitution, @Nullable Multimap<TypeConstructor, TypeProjection> fullSubstitution) {
List<TypeParameterDescriptor> parameters = context.getConstructor().getParameters();
List<TypeProjection> arguments = context.getArguments();
if (parameters.size() != arguments.size()) {
throw new IllegalStateException();
}
for (int i = 0; i < arguments.size(); i++) {
TypeProjection argument = arguments.get(i);
TypeParameterDescriptor typeParameterDescriptor = parameters.get(i);
JetType substitute = substitutor.substitute(argument.getType(), Variance.INVARIANT);
assert substitute != null;
TypeProjection substitutedTypeProjection = new TypeProjection(argument.getProjectionKind(), substitute);
substitution.put(typeParameterDescriptor.getTypeConstructor(), substitutedTypeProjection);
if (fullSubstitution != null) {
fullSubstitution.put(typeParameterDescriptor.getTypeConstructor(), substitutedTypeProjection);
}
}
if (JetStandardClasses.isNothingOrNullableNothing(context)) return;
for (JetType supertype : context.getConstructor().getSupertypes()) {
fillInDeepSubstitutor(supertype, substitutor, substitution, fullSubstitution);
}
}
@NotNull
public static Map<TypeConstructor, TypeProjection> buildSubstitutionContext(@NotNull List<TypeParameterDescriptor> parameters, @NotNull List<TypeProjection> contextArguments) {
Map<TypeConstructor, TypeProjection> parameterValues = new HashMap<TypeConstructor, TypeProjection>();
fillInSubstitutionContext(parameters, contextArguments, parameterValues);
return parameterValues;
}
private static void fillInSubstitutionContext(List<TypeParameterDescriptor> parameters, List<TypeProjection> contextArguments, Map<TypeConstructor, TypeProjection> parameterValues) {
for (int i = 0, parametersSize = parameters.size(); i < parametersSize; i++) {
TypeParameterDescriptor parameter = parameters.get(i);
TypeProjection value = contextArguments.get(i);
parameterValues.put(parameter.getTypeConstructor(), value);
}
}
@NotNull
public static TypeProjection makeStarProjection(@NotNull TypeParameterDescriptor parameterDescriptor) {
return new TypeProjection(Variance.OUT_VARIANCE, parameterDescriptor.getUpperBoundsAsType());
}
private static void collectImmediateSupertypes(@NotNull JetType type, @NotNull Collection<JetType> result) {
TypeSubstitutor substitutor = TypeSubstitutor.create(type);
for (JetType supertype : type.getConstructor().getSupertypes()) {
@@ -546,21 +472,19 @@ public class TypeUtils {
return new ArrayList<ClassDescriptor>(classDescriptors);
}
public static boolean hasUnsubstitutedTypeParameters(JetType type) {
if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
return true;
}
for(TypeProjection proj : type.getArguments()) {
if(hasUnsubstitutedTypeParameters(proj.getType())) {
return true;
}
}
return false;
}
public static boolean equalTypes(@NotNull JetType a, @NotNull JetType b) {
return JetTypeChecker.INSTANCE.isSubtypeOf(a, b) && JetTypeChecker.INSTANCE.isSubtypeOf(b, a);
}
public static boolean typeConstructorUsedInType(@NotNull TypeConstructor key, @NotNull JetType value) {
if (value.getConstructor() == key) return true;
for (TypeProjection projection : value.getArguments()) {
if (typeConstructorUsedInType(key, projection.getType())) {
return true;
}
}
return false;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java
+8 -4
View File
@@ -285,7 +285,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
{
Multimap<TypeConstructor, TypeProjection> typeSubstitutionMap =
TypeUtils.buildDeepSubstitutionMultimap(targetType);
SubstitutionUtils.buildDeepSubstitutionMultimap(targetType);
for (int i = 0; i < actualType.getConstructor().getParameters().size(); ++i) {
TypeProjection actualTypeParameter = actualType.getArguments().get(i);
@@ -310,7 +310,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
(ClassDescriptor) targetType.getConstructor().getDeclarationDescriptor(), null);
Multimap<TypeConstructor, TypeProjection> clearTypeSubstitutionMap =
TypeUtils.buildDeepSubstitutionMultimap(targetTypeClerared);
SubstitutionUtils.buildDeepSubstitutionMultimap(targetTypeClerared);
Set<JetType> clearSubstituted = new HashSet<JetType>();
@@ -332,7 +332,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
}
// "is List<*>"
if (typeProjection.equals(TypeUtils.makeStarProjection(typeParameter))) {
if (typeProjection.equals(SubstitutionUtils.makeStarProjection(typeParameter))) {
continue;
}
@@ -472,6 +472,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
if (result != null) {
context.trace.record(BindingContext.EXPRESSION_TYPE, expression.getInstanceReference(), result);
context.trace.record(BindingContext.REFERENCE_TARGET, expression.getInstanceReference(), result.getConstructor().getDeclarationDescriptor());
if (superTypeQualifier != null) {
context.trace.record(BindingContext.TYPE_RESOLUTION_SCOPE, superTypeQualifier, context.scope);
}
}
}
return DataFlowUtils.checkType(result, expression, context);
@@ -956,7 +959,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
}
}
private boolean isSenselessComparisonWithNull(JetType firstType, JetExpression secondExpression) {
private boolean isSenselessComparisonWithNull(@Nullable JetType firstType, @NotNull JetExpression secondExpression) {
if (firstType == null) return false;
return !firstType.isNullable() && secondExpression instanceof JetConstantExpression && secondExpression.getNode().getElementType() == JetNodeTypes.NULL;
}
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java
+2 -2
View File
@@ -134,10 +134,10 @@ public class ExpressionTypingUtils {
public static void checkWrappingInRef(JetSimpleNameExpression expression, ExpressionTypingContext context) {
VariableDescriptor variable = BindingContextUtils.extractVariableDescriptorIfAny(context.trace.getBindingContext(), expression, true);
if (variable != null && variable.isVar()) {
if (variable != null) {
DeclarationDescriptor containingDeclaration = variable.getContainingDeclaration();
if (context.scope.getContainingDeclaration() != containingDeclaration && containingDeclaration instanceof CallableDescriptor) {
context.trace.record(MUST_BE_WRAPPED_IN_A_REF, variable);
context.trace.record(CAPTURED_IN_CLOSURE, variable);
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java
+24 -5
View File
@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.types.lang;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.intellij.openapi.util.Pair;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
@@ -25,6 +26,8 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.FqName;
import org.jetbrains.jet.lang.resolve.scopes.*;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.JetTypeImpl;
@@ -189,16 +192,23 @@ public class JetStandardClasses {
STANDARD_CLASSES_NAMESPACE,
Collections.<AnnotationDescriptor>emptyList(),
"Function" + i);
SimpleFunctionDescriptorImpl invoke = new SimpleFunctionDescriptorImpl(function, Collections.<AnnotationDescriptor>emptyList(), "invoke", CallableMemberDescriptor.Kind.DECLARATION);
WritableScope scopeForInvoke = createScopeForInvokeFunction(function, invoke);
List<TypeParameterDescriptor> typeParameters = createTypeParameters(i, function);
FUNCTION[i] = function.initialize(
false,
createTypeParameters(i, function),
Collections.singleton(getAnyType()), STUB, Collections.<ConstructorDescriptor>emptySet(), null);
typeParameters,
Collections.singleton(getAnyType()), scopeForInvoke, Collections.<ConstructorDescriptor>emptySet(), null);
FUNCTION_TYPE_CONSTRUCTORS.add(FUNCTION[i].getTypeConstructor());
FunctionDescriptorUtil.initializeFromFunctionType(invoke, function.getDefaultType(), new ClassReceiver(FUNCTION[i]), Modality.ABSTRACT, Visibilities.PUBLIC);
ClassDescriptorImpl receiverFunction = new ClassDescriptorImpl(
STANDARD_CLASSES_NAMESPACE,
Collections.<AnnotationDescriptor>emptyList(),
"ExtensionFunction" + i);
SimpleFunctionDescriptorImpl invokeWithReceiver = new SimpleFunctionDescriptorImpl(receiverFunction, Collections.<AnnotationDescriptor>emptyList(), "invoke", CallableMemberDescriptor.Kind.DECLARATION);
WritableScope scopeForInvokeWithReceiver = createScopeForInvokeFunction(receiverFunction, invokeWithReceiver);
List<TypeParameterDescriptor> parameters = createTypeParameters(i, receiverFunction);
parameters.add(0, TypeParameterDescriptor.createWithDefaultBound(
receiverFunction,
@@ -207,11 +217,19 @@ public class JetStandardClasses {
RECEIVER_FUNCTION[i] = receiverFunction.initialize(
false,
parameters,
Collections.singleton(getAnyType()), STUB, Collections.<ConstructorDescriptor>emptySet(), null);
Collections.singleton(getAnyType()), scopeForInvokeWithReceiver, Collections.<ConstructorDescriptor>emptySet(), null);
RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.add(RECEIVER_FUNCTION[i].getTypeConstructor());
FunctionDescriptorUtil.initializeFromFunctionType(invokeWithReceiver, receiverFunction.getDefaultType(), new ClassReceiver(RECEIVER_FUNCTION[i]), Modality.ABSTRACT, Visibilities.PUBLIC);
}
}
private static WritableScope createScopeForInvokeFunction(ClassDescriptorImpl function, SimpleFunctionDescriptorImpl invoke) {
WritableScope scopeForInvoke = new WritableScopeImpl(STUB, function, RedeclarationHandler.THROW_EXCEPTION).setDebugName("Scope for function type");
scopeForInvoke.addFunctionDescriptor(invoke);
scopeForInvoke.changeLockLevel(WritableScope.LockLevel.READING);
return scopeForInvoke;
}
private static List<TypeParameterDescriptor> createTypeParameters(int parameterCount, ClassDescriptorImpl function) {
List<TypeParameterDescriptor> parameters = new ArrayList<TypeParameterDescriptor>();
for (int j = 0; j < parameterCount; j++) {
@@ -411,8 +429,9 @@ public class JetStandardClasses {
}
arguments.add(defaultProjection(returnType));
int size = parameterTypes.size();
TypeConstructor constructor = receiverType == null ? FUNCTION[size].getTypeConstructor() : RECEIVER_FUNCTION[size].getTypeConstructor();
return new JetTypeImpl(annotations, constructor, false, arguments, STUB);
ClassDescriptor classDescriptor = receiverType == null ? FUNCTION[size] : RECEIVER_FUNCTION[size];
TypeConstructor constructor = classDescriptor.getTypeConstructor();
return new JetTypeImpl(annotations, constructor, false, arguments, classDescriptor.getMemberScope(arguments));
}
private static TypeProjection defaultProjection(JetType returnType) {
compiler/frontend/src/org/jetbrains/jet/plugin/JetFileType.java
+5 -1
View File
@@ -32,7 +32,7 @@ public class JetFileType extends LanguageFileType {
@NotNull
@Override
protected Icon compute() {
return IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/kotlin16x16.png");
return IconLoader.getIcon("/org/jetbrains/jet/plugin/icons/kotlin_file.png");
}
};
@@ -40,21 +40,25 @@ public class JetFileType extends LanguageFileType {
super(JetLanguage.INSTANCE);
}
@Override
@NotNull
public String getName() {
return "Kotlin";
}
@Override
@NotNull
public String getDescription() {
return "Kotlin";
}
@Override
@NotNull
public String getDefaultExtension() {
return "kt";
}
@Override
public Icon getIcon() {
return myIcon.getValue();
}
compiler/integration-tests/compiler-integration-tests.iml
-11
View File
@@ -7,17 +7,6 @@
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="module-library">
<library>
<CLASSES>
<root url="jar://$MODULE_DIR$/../../ideaSDK/lib/junit-4.10.jar!/" />
</CLASSES>
<JAVADOC />
<SOURCES>
<root url="jar://$MODULE_DIR$/../../ideaSDK/lib/junit-4.10-sources.jar!/" />
</SOURCES>
</library>
</orderEntry>
<orderEntry type="library" name="idea-full" level="project" />
</component>
</module>
compiler/integration-tests/data/hello.compile.gold → compiler/integration-tests/data/hello.compile.expected
View File
compiler/integration-tests/data/hello.run.gold → compiler/integration-tests/data/hello.run.expected
View File

Some files were not shown because too many files have changed in this diff Show More