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/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
+1 -1
View File
@@ -80,7 +80,7 @@ public class ClosureCodegen extends GenerationStateAware {
interfaceFunction = getInvokeFunction(funDescriptor); interfaceFunction = getInvokeFunction(funDescriptor);
} }
else { else {
interfaceFunction = SingleAbstractMethodUtils.getAbstractMethodOfFunctionalInterface(samInterface); interfaceFunction = SingleAbstractMethodUtils.getAbstractMethodOfSamInterface(samInterface);
} }
SignatureWriter signatureWriter = new SignatureWriter(); SignatureWriter signatureWriter = new SignatureWriter();
compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+4 -4
View File
@@ -1882,10 +1882,10 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
} }
else { else {
if (funDescriptor instanceof SimpleFunctionDescriptor) { if (funDescriptor instanceof SimpleFunctionDescriptor) {
ClassDescriptor samTrait = bindingContext.get( ClassDescriptor samInterface = bindingContext.get(
BindingContext.SAM_CONSTRUCTOR_TO_TRAIT, ((SimpleFunctionDescriptor) funDescriptor).getOriginal()); BindingContext.SAM_CONSTRUCTOR_TO_INTERFACE, ((SimpleFunctionDescriptor) funDescriptor).getOriginal());
if (samTrait != null) { if (samInterface != null) {
ResolvedValueArgument argument = resolvedCall.getValueArgumentsByIndex().get(0); ResolvedValueArgument argument = resolvedCall.getValueArgumentsByIndex().get(0);
if (!(argument instanceof ExpressionValueArgument)) { if (!(argument instanceof ExpressionValueArgument)) {
throw new IllegalStateException( throw new IllegalStateException(
@@ -1896,7 +1896,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
JetExpression argumentExpression = valueArgument.getArgumentExpression(); JetExpression argumentExpression = valueArgument.getArgumentExpression();
if (argumentExpression instanceof JetFunctionLiteralExpression) { if (argumentExpression instanceof JetFunctionLiteralExpression) {
return genClosure(((JetFunctionLiteralExpression) argumentExpression).getFunctionLiteral(), samTrait); return genClosure(((JetFunctionLiteralExpression) argumentExpression).getFunctionLiteral(), samInterface);
} }
else { else {
throw new UnsupportedOperationException(); // TODO throw new UnsupportedOperationException(); // TODO
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) { if (JetClassAnnotation.get(psiClass).kind() == JvmStdlibNames.FLAG_CLASS_KIND_OBJECT) {
processObjectClass(psiClass); processObjectClass(psiClass);
} }
if (!DescriptorResolverUtils.isKotlinClass(psiClass) && isFunctionalInterface(psiClass)) { if (!DescriptorResolverUtils.isKotlinClass(psiClass) && isSamInterface(psiClass)) {
processFunctionalInterface(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 namedMembers = getOrCreateEmpty(Name.identifier(psiClass.getName()));
namedMembers.setFunctionalInterface(psiClass); namedMembers.setSamInterface(psiClass);
} }
} }
@@ -307,9 +307,9 @@ public final class MembersCache {
return; return;
} }
for (PsiClass nested : psiClass.getPsiClass().getInnerClasses()) { for (PsiClass nested : psiClass.getPsiClass().getInnerClasses()) {
if (isFunctionalInterface(nested)) { if (isSamInterface(nested)) {
NamedMembers namedMembers = getOrCreateEmpty(Name.identifier(nested.getName())); 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); return OBJECT_METHODS.contains(formattedMethod);
} }
public static boolean isFunctionalInterface(@NotNull PsiClass psiClass) { public static boolean isSamInterface(@NotNull PsiClass psiClass) {
if (!psiClass.isInterface()) { if (!psiClass.isInterface()) {
return false; 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(); private final List<PropertyPsiDataElement> propertyPsiDataElements = Lists.newArrayList();
@Nullable @Nullable
private PsiClass functionalInterface; private PsiClass samInterface;
void addMethod(@NotNull PsiMethodWrapper method) { void addMethod(@NotNull PsiMethodWrapper method) {
methods.add(method); methods.add(method);
@@ -52,8 +52,8 @@ public final class NamedMembers {
propertyPsiDataElements.add(propertyPsiDataElement); propertyPsiDataElements.add(propertyPsiDataElement);
} }
void setFunctionalInterface(@NotNull PsiClass functionalInterface) { void setSamInterface(@NotNull PsiClass samInterface) {
this.functionalInterface = functionalInterface; this.samInterface = samInterface;
} }
@NotNull @NotNull
@@ -72,7 +72,7 @@ public final class NamedMembers {
} }
@Nullable @Nullable
public PsiClass getFunctionalInterface() { public PsiClass getSamInterface() {
return functionalInterface; 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.Lists;
import com.google.common.collect.Sets; import com.google.common.collect.Sets;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.diagnostic.Logger;
import com.intellij.psi.PsiClass; import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiMethod;
@@ -358,12 +357,13 @@ public final class JavaFunctionResolver {
@NotNull NamespaceDescriptor ownerDescriptor, @NotNull NamespaceDescriptor ownerDescriptor,
@NotNull NamedMembers namedMembers @NotNull NamedMembers namedMembers
) { ) {
PsiClass functionalInterface = namedMembers.getFunctionalInterface(); PsiClass samInterface = namedMembers.getSamInterface();
if (functionalInterface != null) { if (samInterface != null) {
ClassDescriptor klass = findClassInNamespace(ownerDescriptor, namedMembers.getName()); ClassDescriptor klass = findClassInNamespace(ownerDescriptor, namedMembers.getName());
if (klass != null && SingleAbstractMethodUtils.isFunctionalInterface(klass)) { if (klass != null && SingleAbstractMethodUtils.isSamInterface(klass)) {
SimpleFunctionDescriptor constructorFunction = SingleAbstractMethodUtils.createConstructorFunction(ownerDescriptor, klass); SimpleFunctionDescriptor constructorFunction = SingleAbstractMethodUtils.createSamConstructorFunction(ownerDescriptor,
trace.record(BindingContext.SAM_CONSTRUCTOR_TO_TRAIT, constructorFunction, klass); klass);
trace.record(BindingContext.SAM_CONSTRUCTOR_TO_INTERFACE, constructorFunction, klass);
return constructorFunction; 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()) { for (PsiClass nestedClass : psiClass.getInnerClasses()) {
if (MembersCache.isFunctionalInterface(nestedClass)) { if (MembersCache.isSamInterface(nestedClass)) {
return true; return true;
} }
if (nestedClass.hasModifierProperty(PsiModifier.STATIC) && hasStaticMembers(nestedClass)) { 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; import java.util.Map;
public class SingleAbstractMethodUtils { public class SingleAbstractMethodUtils {
public static boolean isFunctionalInterface(@NotNull ClassDescriptor klass) { public static boolean isSamInterface(@NotNull ClassDescriptor klass) {
if (klass.getKind() != ClassKind.TRAIT) { if (klass.getKind() != ClassKind.TRAIT) {
return false; return false;
} }
@@ -63,7 +63,7 @@ public class SingleAbstractMethodUtils {
} }
@NotNull @NotNull
private static JetType getFunctionalTypeForFunction(@NotNull FunctionDescriptor function) { private static JetType getFunctionTypeForFunction(@NotNull FunctionDescriptor function) {
JetType returnType = function.getReturnType(); JetType returnType = function.getReturnType();
assert returnType != null : "function is not initialized: " + function; assert returnType != null : "function is not initialized: " + function;
List<JetType> parameterTypes = Lists.newArrayList(); List<JetType> parameterTypes = Lists.newArrayList();
@@ -73,25 +73,28 @@ public class SingleAbstractMethodUtils {
return KotlinBuiltIns.getInstance().getFunctionType(Collections.<AnnotationDescriptor>emptyList(), null, parameterTypes, returnType); 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( SimpleFunctionDescriptorImpl result = new SimpleFunctionDescriptorImpl(
owner, owner,
klass.getAnnotations(), samInterface.getAnnotations(),
klass.getName(), samInterface.getName(),
CallableMemberDescriptor.Kind.SYNTHESIZED CallableMemberDescriptor.Kind.SYNTHESIZED
); );
Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> traitToFunTypeParameters = Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> traitToFunTypeParameters =
SignaturesUtil.recreateTypeParametersAndReturnMapping(klass.getTypeConstructor().getParameters(), result); SignaturesUtil.recreateTypeParametersAndReturnMapping(samInterface.getTypeConstructor().getParameters(), result);
TypeSubstitutor typeParametersSubstitutor = SignaturesUtil.createSubstitutorForTypeParameters(traitToFunTypeParameters); TypeSubstitutor typeParametersSubstitutor = SignaturesUtil.createSubstitutorForTypeParameters(traitToFunTypeParameters);
JetType parameterTypeUnsubstituted = getFunctionalTypeForFunction(getAbstractMethodOfFunctionalInterface(klass)); JetType parameterTypeUnsubstituted = getFunctionTypeForFunction(getAbstractMethodOfSamInterface(samInterface));
JetType parameterType = typeParametersSubstitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE); JetType parameterType = typeParametersSubstitutor.substitute(parameterTypeUnsubstituted, Variance.IN_VARIANCE);
assert parameterType != null : "couldn't substitute type: " + parameterType + ", substitutor = " + typeParametersSubstitutor; assert parameterType != null : "couldn't substitute type: " + parameterType + ", substitutor = " + typeParametersSubstitutor;
ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl( ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl(
result, 0, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("function"), parameterType, false, null); 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; assert returnType != null : "couldn't substitute type: " + returnType + ", substitutor = " + typeParametersSubstitutor;
for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> mapEntry : traitToFunTypeParameters.entrySet()) { for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> mapEntry : traitToFunTypeParameters.entrySet()) {
@@ -114,7 +117,7 @@ public class SingleAbstractMethodUtils {
Arrays.asList(parameter), Arrays.asList(parameter),
returnType, returnType,
Modality.FINAL, Modality.FINAL,
klass.getVisibility(), samInterface.getVisibility(),
false false
); );
@@ -122,8 +125,8 @@ public class SingleAbstractMethodUtils {
} }
@NotNull @NotNull
public static SimpleFunctionDescriptor getAbstractMethodOfFunctionalInterface(@NotNull ClassDescriptor klass) { public static SimpleFunctionDescriptor getAbstractMethodOfSamInterface(@NotNull ClassDescriptor samInterface) {
return (SimpleFunctionDescriptor) getAbstractMembers(klass).get(0); return (SimpleFunctionDescriptor) getAbstractMembers(samInterface).get(0);
} }
private SingleAbstractMethodUtils() { private SingleAbstractMethodUtils() {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
+1 -1
View File
@@ -255,7 +255,7 @@ public interface BindingContext {
new BasicWritableSlice<DeclarationDescriptor, List<String>>(Slices.ONLY_REWRITE_TO_EQUAL, true); new BasicWritableSlice<DeclarationDescriptor, List<String>>(Slices.ONLY_REWRITE_TO_EQUAL, true);
WritableSlice<CallableDescriptor, Boolean> IS_DECLARED_IN_JAVA = Slices.createSimpleSlice(); WritableSlice<CallableDescriptor, Boolean> IS_DECLARED_IN_JAVA = Slices.createSimpleSlice();
WritableSlice<SimpleFunctionDescriptor, ClassDescriptor> SAM_CONSTRUCTOR_TO_TRAIT = Slices.createSimpleSlice(); WritableSlice<SimpleFunctionDescriptor, ClassDescriptor> SAM_CONSTRUCTOR_TO_INTERFACE = Slices.createSimpleSlice();
@SuppressWarnings("UnusedDeclaration") @SuppressWarnings("UnusedDeclaration")
@Deprecated // This field is needed only for the side effects of its initializer @Deprecated // This field is needed only for the side effects of its initializer