From 4c27b5caf806f0a4736820a27623dfd62134eb58 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 29 Sep 2011 20:28:03 +0400 Subject: [PATCH] Named and default arguments tuned up a little bit --- .../jet/lang/diagnostics/Errors.java | 4 +-- .../UnresolvedReferenceDiagnostic.java | 4 +-- .../UnresolvedReferenceDiagnosticFactory.java | 10 ++++-- .../jet/lang/resolve/calls/CallResolver.java | 27 ++++++++------- .../ValueArgumentsToParametersMapper.java | 34 ++++++++----------- .../jet/plugin/annotations/JetPsiChecker.java | 12 +++---- .../quick/NamedArgumentsAndDefaultValues.jet | 20 +++++++++++ 7 files changed, 65 insertions(+), 46 deletions(-) create mode 100644 idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index f1bdceb1172..87535768bfb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -42,7 +42,7 @@ public interface Errors { return e.getClass().getSimpleName() + ": " + e.getMessage(); } }; - UnresolvedReferenceDiagnosticFactory UNRESOLVED_REFERENCE = UnresolvedReferenceDiagnosticFactory.INSTANCE; + UnresolvedReferenceDiagnosticFactory UNRESOLVED_REFERENCE = new UnresolvedReferenceDiagnosticFactory("Unresolved reference"); RedeclarationDiagnosticFactory REDECLARATION = RedeclarationDiagnosticFactory.INSTANCE; PsiElementOnlyDiagnosticFactory2 TYPE_MISMATCH = PsiElementOnlyDiagnosticFactory2.create(ERROR, "Type mismatch: inferred type is {1} but {0} was expected"); ParameterizedDiagnosticFactory1> INCOMPATIBLE_MODIFIERS = new ParameterizedDiagnosticFactory1>(ERROR, "Incompatible modifiers: ''{0}''") { @@ -82,7 +82,7 @@ public interface Errors { SimpleDiagnosticFactory NO_BACKING_FIELD = SimpleDiagnosticFactory.create(ERROR, "This property does not have a backing field"); SimpleDiagnosticFactory MIXING_NAMED_AND_POSITIONED_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR, "Mixing named and positioned arguments in not allowed"); SimpleDiagnosticFactory ARGUMENT_PASSED_TWICE = SimpleDiagnosticFactory.create(ERROR, "An argument is already passed for this parameter"); - SimpleDiagnosticFactory NAMED_PARAMETER_NOT_FOUND = SimpleDiagnosticFactory.create(ERROR, "Cannot find a parameter with this name"); + UnresolvedReferenceDiagnosticFactory NAMED_PARAMETER_NOT_FOUND = new UnresolvedReferenceDiagnosticFactory("Cannot find a parameter with this name");//SimpleDiagnosticFactory.create(ERROR, "Cannot find a parameter with this name"); SimpleDiagnosticFactory VARARG_OUTSIDE_PARENTHESES = SimpleDiagnosticFactory.create(ERROR, "Passing value as a vararg is only allowed inside a parenthesized argument list"); SimpleDiagnosticFactory MANY_FUNCTION_LITERAL_ARGUMENTS = SimpleDiagnosticFactory.create(ERROR, "Only one function literal is allowed outside a parenthesized argument list"); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java index 3e41219d46a..1d248f97638 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnostic.java @@ -10,8 +10,8 @@ import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR; */ public class UnresolvedReferenceDiagnostic extends DiagnosticWithPsiElementImpl { - public UnresolvedReferenceDiagnostic(JetReferenceExpression referenceExpression) { - super(Errors.UNRESOLVED_REFERENCE, ERROR, "Unresolved reference", referenceExpression); + public UnresolvedReferenceDiagnostic(JetReferenceExpression referenceExpression, String message) { + super(Errors.UNRESOLVED_REFERENCE, ERROR, message, referenceExpression); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java index 8dcd7d87bf8..f5bbc087fd8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnresolvedReferenceDiagnosticFactory.java @@ -7,11 +7,15 @@ import org.jetbrains.jet.lang.psi.JetReferenceExpression; * @author abreslav */ public class UnresolvedReferenceDiagnosticFactory extends AbstractDiagnosticFactory { - public static final UnresolvedReferenceDiagnosticFactory INSTANCE = new UnresolvedReferenceDiagnosticFactory(); +// public static final UnresolvedReferenceDiagnosticFactory INSTANCE = new UnresolvedReferenceDiagnosticFactory(); - public UnresolvedReferenceDiagnosticFactory() {} + private final String message; + + public UnresolvedReferenceDiagnosticFactory(String message) { + this.message = message; + } public UnresolvedReferenceDiagnostic on(@NotNull JetReferenceExpression reference) { - return new UnresolvedReferenceDiagnostic(reference); + return new UnresolvedReferenceDiagnostic(reference, message); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index ec4ce7e7ee9..d37dfa72ee0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -214,19 +214,20 @@ public class CallResolver { @Override public void noValueForParameter(@NotNull BindingTrace trace, @NotNull ValueParameterDescriptor valueParameter) { - ASTNode node; - - JetValueArgumentList valueArgumentList = call.getValueArgumentList(); - if (valueArgumentList != null) { - node = valueArgumentList.getNode(); - } - else if (!call.getFunctionLiteralArguments().isEmpty()) { - node = call.getFunctionLiteralArguments().get(0).getNode(); - } - else { - node = callNode; - } - trace.report(NO_VALUE_FOR_PARAMETER.on(node, valueParameter)); +// ASTNode node; +// +// JetValueArgumentList valueArgumentList = call.getValueArgumentList(); +// if (valueArgumentList != null) { +// node = valueArgumentList.getNode(); +// } +// else if (!call.getFunctionLiteralArguments().isEmpty()) { +// node = call.getFunctionLiteralArguments().get(0).getNode(); +// } +// else { +// node = callNode; +// } +// trace.report(NO_VALUE_FOR_PARAMETER.on(node, valueParameter)); + trace.report(NO_VALUE_FOR_PARAMETER.on(reference, valueParameter)); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java index dbb17dff53a..9792f35e9c4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java @@ -2,14 +2,10 @@ package org.jetbrains.jet.lang.resolve.calls; import com.google.common.collect.Maps; 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.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetFunctionLiteralExpression; -import org.jetbrains.jet.lang.psi.JetLabelQualifiedExpression; -import org.jetbrains.jet.lang.psi.ValueArgument; +import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.types.CallMaker; @@ -49,27 +45,25 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; ValueArgument valueArgument = valueArguments.get(i); if (valueArgument.isNamed()) { someNamed = true; - ASTNode nameNode = valueArgument.getArgumentName().getNode(); - if (somePositioned) { -// temporaryTrace.getErrorHandler().genericError(nameNode, "Mixing named and positioned arguments in not allowed"); - temporaryTrace.report(MIXING_NAMED_AND_POSITIONED_ARGUMENTS.on(nameNode)); + JetReferenceExpression nameReference = valueArgument.getArgumentName().getReferenceExpression(); + ValueParameterDescriptor valueParameterDescriptor = parameterByName.get(valueArgument.getArgumentName().getReferenceExpression().getReferencedName()); + if (valueParameterDescriptor == null) { +// temporaryTrace.getErrorHandler().genericError(nameNode, "Cannot find a parameter with this name"); + temporaryTrace.report(NAMED_PARAMETER_NOT_FOUND.on(nameReference)); error = true; } else { - ValueParameterDescriptor valueParameterDescriptor = parameterByName.get(valueArgument.getArgumentName().getReferenceExpression().getReferencedName()); if (!usedParameters.add(valueParameterDescriptor)) { // temporaryTrace.getErrorHandler().genericError(nameNode, "An argument is already passed for this parameter"); - temporaryTrace.report(ARGUMENT_PASSED_TWICE.on(nameNode)); - } - if (valueParameterDescriptor == null) { -// temporaryTrace.getErrorHandler().genericError(nameNode, "Cannot find a parameter with this name"); - temporaryTrace.report(NAMED_PARAMETER_NOT_FOUND.on(nameNode)); - error = true; - } - else { - temporaryTrace.record(REFERENCE_TARGET, valueArgument.getArgumentName().getReferenceExpression(), valueParameterDescriptor); - argumentsToParameters.put(valueArgument, valueParameterDescriptor); + temporaryTrace.report(ARGUMENT_PASSED_TWICE.on(nameReference)); } + temporaryTrace.record(REFERENCE_TARGET, nameReference, valueParameterDescriptor); + argumentsToParameters.put(valueArgument, valueParameterDescriptor); + } + if (somePositioned) { +// temporaryTrace.getErrorHandler().genericError(nameNode, "Mixing named and positioned arguments in not allowed"); + temporaryTrace.report(MIXING_NAMED_AND_POSITIONED_ARGUMENTS.on(nameReference)); + error = true; } } else { diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java b/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java index f3f1293b5c5..a845fd21838 100644 --- a/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java +++ b/idea/src/org/jetbrains/jet/plugin/annotations/JetPsiChecker.java @@ -8,6 +8,7 @@ import com.intellij.lang.annotation.AnnotationHolder; import com.intellij.lang.annotation.Annotator; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.progress.ProcessCanceledException; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.TextRange; import com.intellij.psi.MultiRangeReference; import com.intellij.psi.PsiElement; @@ -29,9 +30,7 @@ import org.jetbrains.jet.plugin.quickfix.QuickFixes; import java.util.Collection; import java.util.Set; -import static org.jetbrains.jet.lang.resolve.BindingContext.AUTOCAST; -import static org.jetbrains.jet.lang.resolve.BindingContext.AUTO_CREATED_IT; -import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; +import static org.jetbrains.jet.lang.resolve.BindingContext.*; /** * @author abreslav @@ -52,11 +51,12 @@ public class JetPsiChecker implements Annotator { public void annotate(@NotNull PsiElement element, @NotNull final AnnotationHolder holder) { if (element instanceof JetFile) { JetFile file = (JetFile) element; + Project project = element.getProject(); try { final BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file); if (errorReportingEnabled) { - Collection diagnostics = bindingContext.getDiagnostics(); + Collection diagnostics = Sets.newLinkedHashSet(bindingContext.getDiagnostics()); Set redeclarations = Sets.newHashSet(); for (Diagnostic diagnostic : diagnostics) { Annotation annotation = null; @@ -68,11 +68,11 @@ public class JetPsiChecker implements Annotator { if (reference instanceof MultiRangeReference) { MultiRangeReference mrr = (MultiRangeReference) reference; for (TextRange range : mrr.getRanges()) { - holder.createErrorAnnotation(range.shiftRight(referenceExpression.getTextOffset()), "Unresolved").setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); + holder.createErrorAnnotation(range.shiftRight(referenceExpression.getTextOffset()), diagnostic.getMessage()).setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); } } else { - holder.createErrorAnnotation(referenceExpression, "Unresolved").setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); + holder.createErrorAnnotation(referenceExpression, diagnostic.getMessage()).setHighlightType(ProblemHighlightType.LIKE_UNKNOWN_SYMBOL); } } else if (diagnostic instanceof RedeclarationDiagnostic) { diff --git a/idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet b/idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet new file mode 100644 index 00000000000..a021255f0d7 --- /dev/null +++ b/idea/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet @@ -0,0 +1,20 @@ +fun foo(a : Int = 1, b : String = "abc") { +} + +fun test() { + foo() + foo(2) + foo("") + foo(b = "") + foo(1, "") + foo(a = 2) + foo(1, "", "") + + bar(z = "") + bar() + bar("") + bar(1, 1, "") + bar(1, 1, "") + bar(1, z = "") + bar(1, zz = "", zz.foo) +} \ No newline at end of file