From 9d32723cbfd7d1aa20940a7607bfbc66f8c21d06 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 14 Apr 2011 19:31:22 +0400 Subject: [PATCH] CF for new-expression --- .../jet/lang/cfg/JetControlFlowProcessor.java | 27 +++++++++++++------ .../org/jetbrains/jet/lang/psi/JetCall.java | 20 ++++++++++++++ .../jet/lang/psi/JetCallExpression.java | 5 +++- .../jet/lang/psi/JetNewExpression.java | 11 +++++--- .../jet/lang/types/JetTypeChecker.java | 2 +- .../jet/lang/types/JetTypeInferrer.java | 6 ++--- 6 files changed, 54 insertions(+), 17 deletions(-) create mode 100644 idea/src/org/jetbrains/jet/lang/psi/JetCall.java diff --git a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java index d73a33835a2..5d8dfe15e30 100644 --- a/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java +++ b/idea/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java @@ -472,27 +472,38 @@ public class JetControlFlowProcessor { builder.readNode(expression); } - @Override - public void visitCallExpression(JetCallExpression expression) { - for (JetTypeProjection typeArgument : expression.getTypeArguments()) { - value(typeArgument, false, false); - } - - for (JetArgument argument : expression.getValueArguments()) { + private void visitCall(JetCall call) { + for (JetArgument argument : call.getValueArguments()) { JetExpression argumentExpression = argument.getArgumentExpression(); if (argumentExpression != null) { value(argumentExpression, false, false); } } - for (JetExpression functionLiteral : expression.getFunctionLiteralArguments()) { + for (JetExpression functionLiteral : call.getFunctionLiteralArguments()) { value(functionLiteral, false, false); } + } + + @Override + public void visitCallExpression(JetCallExpression expression) { + for (JetTypeProjection typeArgument : expression.getTypeArguments()) { + value(typeArgument, false, false); + } + + visitCall(expression); value(expression.getCalleeExpression(), false, false); builder.readNode(expression); } + @Override + public void visitNewExpression(JetNewExpression expression) { + // TODO : Instantiated class is loaded + // TODO : type arguments? + visitCall(expression); + } + @Override public void visitProperty(JetProperty property) { JetExpression initializer = property.getInitializer(); diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetCall.java b/idea/src/org/jetbrains/jet/lang/psi/JetCall.java new file mode 100644 index 00000000000..9b8b625b805 --- /dev/null +++ b/idea/src/org/jetbrains/jet/lang/psi/JetCall.java @@ -0,0 +1,20 @@ +package org.jetbrains.jet.lang.psi; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.List; + +/** + * @author abreslav + */ +public interface JetCall { + @Nullable + JetArgumentList getValueArgumentList(); + + @NotNull + List getValueArguments(); + + @NotNull + List getFunctionLiteralArguments(); +} diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetCallExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetCallExpression.java index 5102449b6f6..0d7cbf51015 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetCallExpression.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetCallExpression.java @@ -11,7 +11,7 @@ import java.util.List; /** * @author max */ -public class JetCallExpression extends JetExpression { +public class JetCallExpression extends JetExpression implements JetCall { public JetCallExpression(@NotNull ASTNode node) { super(node); } @@ -28,6 +28,7 @@ public class JetCallExpression extends JetExpression { return callee; } + @Override @Nullable public JetArgumentList getValueArgumentList() { return (JetArgumentList) findChildByType(JetNodeTypes.VALUE_ARGUMENT_LIST); @@ -38,11 +39,13 @@ public class JetCallExpression extends JetExpression { return (JetTypeArgumentList) findChildByType(JetNodeTypes.TYPE_ARGUMENT_LIST); } + @Override @NotNull public List getFunctionLiteralArguments() { return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL); } + @Override @NotNull public List getValueArguments() { JetArgumentList list = getValueArgumentList(); diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetNewExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetNewExpression.java index dc5a97ea35f..704a6006bff 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetNewExpression.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetNewExpression.java @@ -11,7 +11,7 @@ import java.util.List; /** * @author max */ -public class JetNewExpression extends JetExpression { +public class JetNewExpression extends JetExpression implements JetCall { public JetNewExpression(@NotNull ASTNode node) { super(node); } @@ -26,17 +26,20 @@ public class JetNewExpression extends JetExpression { return (JetTypeReference) findChildByType(JetNodeTypes.TYPE_REFERENCE); } + @Override @Nullable - public JetArgumentList getArgumentList() { + public JetArgumentList getValueArgumentList() { return (JetArgumentList) findChildByType(JetNodeTypes.VALUE_ARGUMENT_LIST); } + @Override @NotNull - public List getArguments() { - JetArgumentList list = getArgumentList(); + public List getValueArguments() { + JetArgumentList list = getValueArgumentList(); return list != null ? list.getArguments() : Collections.emptyList(); } + @Override @NotNull public List getFunctionLiteralArguments() { return findChildrenByType(JetNodeTypes.FUNCTION_LITERAL); diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java index cece902df9e..387eb004aad 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeChecker.java @@ -295,7 +295,7 @@ public class JetTypeChecker { if (expected.getConstructor().equals(JetStandardClasses.getTuple(0).getTypeConstructor())) { return true; } -// if (actual.getArguments().isEmpty()) { +// if (actual.getValueArguments().isEmpty()) { // TypeConstructor actualConstructor = actual.getConstructor(); // TypeConstructor constructor = expected.getConstructor(); // Set convertibleTo = getConversionMap().get(actualConstructor); diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index 9994d269023..0f0b652a681 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -940,14 +940,14 @@ public class JetTypeInferrer { OverloadDomain constructorsOverloadDomain = semanticServices.getOverloadResolver().getOverloadDomain(constructors); JetType constructorReturnedType = resolveOverloads( scope, - wrapForTracing(constructorsOverloadDomain, referenceExpression, expression.getArgumentList(), false), + wrapForTracing(constructorsOverloadDomain, referenceExpression, expression.getValueArgumentList(), false), Collections.emptyList(), - expression.getArguments(), + expression.getValueArguments(), expression.getFunctionLiteralArguments()); if (constructorReturnedType == null && !ErrorUtils.isErrorType(receiverType)) { trace.recordReferenceResolution(referenceExpression, receiverType.getConstructor().getDeclarationDescriptor()); // TODO : more helpful message - JetArgumentList argumentList = expression.getArgumentList(); + JetArgumentList argumentList = expression.getValueArgumentList(); if (argumentList != null) { semanticServices.getErrorHandler().genericError(argumentList.getNode(), "Cannot find an overload for these arguments"); }