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

Always using "SAM interface" term.

Browse Source
This commit is contained in:
Evgeny Gerashchenko
2013-03-27 19:27:02 +04:00
parent c619685dc8
commit b7527101cd
8 changed files with 39 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java
+7 -7
View File
@@ -94,8 +94,8 @@ public final class MembersCache {
if (JetClassAnnotation.get(psiClass).kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT) {
processObjectClass(psiClass);
}
if (!DescriptorResolverUtils.isKotlinClass(psiClass) && isFunctionalInterface(psiClass)) {
processFunctionalInterface(psiClass);
if (!DescriptorResolverUtils.isKotlinClass(psiClass) && isSamInterface(psiClass)) {
processSamInterface(psiClass);
}
}
}
@@ -111,9 +111,9 @@ public final class MembersCache {
}
}
private void processFunctionalInterface(@NotNull PsiClass psiClass) {
private void processSamInterface(@NotNull PsiClass psiClass) {
NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName()));
namedMembers.setFunctionalInterface(psiClass);
namedMembers.setSamInterface(psiClass);
}
}
@@ -307,9 +307,9 @@ public final class MembersCache {
return;
}
for (PsiClass nested : psiClass.getPsiClass().getInnerClasses()) {
if (isFunctionalInterface(nested)) {
if (isSamInterface(nested)) {
NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(nested.getName()));
namedMembers.setFunctionalInterface(nested);
namedMembers.setSamInterface(nested);
}
}
}
@@ -335,7 +335,7 @@ public final class MembersCache {
return OBJECT_METHODS.contains(formattedMethod);
}
public static boolean isFunctionalInterface(@NotNull PsiClass psiClass) {
public static boolean isSamInterface(@NotNull PsiClass psiClass) {
if (!psiClass.isInterface()) {
return false;
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/NamedMembers.java
+5 -5
View File
@@ -42,7 +42,7 @@ public final class NamedMembers {
private final List<PropertyPsiDataElement> propertyPsiDataElements = Lists.newArrayList();
@Nullable
private PsiClass functionalInterface;
private PsiClass samInterface;
void addMethod(@NotNull PsiMethodWrapper method) {
methods.add(method);
@@ -52,8 +52,8 @@ public final class NamedMembers {
propertyPsiDataElements.add(propertyPsiDataElement);
}
void setFunctionalInterface(@NotNull PsiClass functionalInterface) {
this.functionalInterface = functionalInterface;
void setSamInterface(@NotNull PsiClass samInterface) {
this.samInterface = samInterface;
}
@NotNull
@@ -72,7 +72,7 @@ public final class NamedMembers {
}
@Nullable
public PsiClass getFunctionalInterface() {
return functionalInterface;
public PsiClass getSamInterface() {
return samInterface;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java
+6 -6
View File
@@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiMethod;
@@ -358,12 +357,13 @@ public final class JavaFunctionResolver {
@NotNull NamespaceDescriptor ownerDescriptor,
@NotNull NamedMembers namedMembers
) {
PsiClass functionalInterface = namedMembers.getFunctionalInterface();
if (functionalInterface != null) {
PsiClass samInterface = namedMembers.getSamInterface();
if (samInterface != null) {
ClassDescriptor klass = findClassInNamespace(ownerDescriptor, namedMembers.getName());
if (klass != null && SingleAbstractMethodUtils.isFunctionalInterface(klass)) {
SimpleFunctionDescriptor constructorFunction = SingleAbstractMethodUtils.createConstructorFunction(ownerDescriptor, klass);
trace.record(BindingContext.SAM_CONSTRUCTOR_TO_TRAIT, constructorFunction, klass);
if (klass != null && SingleAbstractMethodUtils.isSamInterface(klass)) {
SimpleFunctionDescriptor constructorFunction = SingleAbstractMethodUtils.createSamConstructorFunction(ownerDescriptor,
klass);
trace.record(BindingContext.SAM_CONSTRUCTOR_TO_INTERFACE, constructorFunction, klass);
return constructorFunction;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java
+1 -1
View File
@@ -221,7 +221,7 @@ public final class JavaNamespaceResolver {
}
for (PsiClass nestedClass : psiClass.getInnerClasses()) {
if (MembersCache.isFunctionalInterface(nestedClass)) {
if (MembersCache.isSamInterface(nestedClass)) {
return true;
}
if (nestedClass.hasModifierProperty(PsiModifier.STATIC) && hasStaticMembers(nestedClass)) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java
+14 -11
View File
@@ -36,7 +36,7 @@ import java.util.List;
import java.util.Map;
public class SingleAbstractMethodUtils {
public static boolean isFunctionalInterface(@NotNull ClassDescriptor klass) {
public static boolean isSamInterface(@NotNull ClassDescriptor klass) {
if (klass.getKind() != ClassKind.TRAIT) {
return false;
}
@@ -63,7 +63,7 @@ public class SingleAbstractMethodUtils {
}
@NotNull
private static JetType getFunctionalTypeForFunction(@NotNull FunctionDescriptor function) {
private static JetType getFunctionTypeForFunction(@NotNull FunctionDescriptor function) {
JetType returnType = function.getReturnType();
assert returnType != null : "function is not initialized: " + function;
List<JetType> parameterTypes = Lists.newArrayList();
@@ -73,25 +73,28 @@ public class SingleAbstractMethodUtils {
return KotlinBuiltIns.getInstance().getFunctionType(Collections.<AnnotationDescriptor>emptyList(), null, parameterTypes, returnType);
}
public static SimpleFunctionDescriptor createConstructorFunction(@NotNull ClassOrNamespaceDescriptor owner, @NotNull ClassDescriptor klass) {
public static SimpleFunctionDescriptor createSamConstructorFunction(
@NotNull ClassOrNamespaceDescriptor owner,
@NotNull ClassDescriptor samInterface
) {
SimpleFunctionDescriptorImpl result = new SimpleFunctionDescriptorImpl(
owner,
klass.getAnnotations(),
klass.getName(),
samInterface.getAnnotations(),
samInterface.getName(),
CallableMemberDescriptor.Kind.SYNTHESIZED
);
Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> traitToFunTypeParameters =
SignaturesUtil.recreateTypeParametersAndReturnMapping(klass.getTypeConstructor().getParameters(), result);
SignaturesUtil.recreateTypeParametersAndReturnMapping(samInterface.getTypeConstructor().getParameters(), result);
TypeSubstitutor typeParametersSubstitutor = SignaturesUtil.createSubstitutorForTypeParameters(traitToFunTypeParameters);
JetType parameterTypeUnsubstituted = getFunctionalTypeForFunction(getAbstractMethodOfFunctionalInterface(klass));
JetType parameterTypeUnsubstituted = getFunctionTypeForFunction(getAbstractMethodOfSamInterface(samInterface));
JetType parameterType = typeParametersSubstitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE);
assert parameterType != null : "couldn't substitute type: " + parameterType + ", substitutor = " + typeParametersSubstitutor;
ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl(
result, 0, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("function"), parameterType, false, null);
JetType returnType = typeParametersSubstitutor.substitute(klass.getDefaultType(), Variance.OUT_VARIANCE);
JetType returnType = typeParametersSubstitutor.substitute(samInterface.getDefaultType(), Variance.OUT_VARIANCE);
assert returnType != null : "couldn't substitute type: " + returnType + ", substitutor = " + typeParametersSubstitutor;
for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> mapEntry : traitToFunTypeParameters.entrySet()) {
@@ -114,7 +117,7 @@ public class SingleAbstractMethodUtils {
Arrays.asList(parameter),
returnType,
Modality.FINAL,
klass.getVisibility(),
samInterface.getVisibility(),
false
);
@@ -122,8 +125,8 @@ public class SingleAbstractMethodUtils {
}
@NotNull
public static SimpleFunctionDescriptor getAbstractMethodOfFunctionalInterface(@NotNull ClassDescriptor klass) {
return (SimpleFunctionDescriptor) getAbstractMembers(klass).get(0);
public static SimpleFunctionDescriptor getAbstractMethodOfSamInterface(@NotNull ClassDescriptor samInterface) {
return (SimpleFunctionDescriptor) getAbstractMembers(samInterface).get(0);
}
private SingleAbstractMethodUtils() {