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

Merge branch 'master' of git+ssh://git.labs.intellij.net/jet

Browse Source
This commit is contained in:
Nikolay Krasko
2011-11-30 19:54:35 +04:00
parent 1e3c45e65c 49c29dd323
commit ffc5db6c35
227 changed files with 1131 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java
+16 -6
View File
@@ -4,15 +4,13 @@ import com.intellij.psi.util.PsiTreeUtil;
import gnu.trove.THashSet;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.psi.JetClass;
import org.jetbrains.jet.lang.psi.JetNamedDeclaration;
import org.jetbrains.jet.lang.psi.JetNamespace;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.calls.ExpressionAsFunctionDescriptor;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
import org.jetbrains.jet.lang.types.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetType;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
@@ -115,10 +113,22 @@ public class CodegenUtil {
if (parent != null) {
String parentFQName = getFQName(parent);
if (parentFQName.length() > 0) {
return parentFQName + "." + jetNamespace.getName();
return parentFQName + "." + getFQName(jetNamespace.getHeader());
}
}
return jetNamespace.getName(); // TODO: Must include module root namespace
return getFQName(jetNamespace.getHeader()); // TODO: Must include module root namespace
}
private static String getFQName(JetNamespaceHeader header) {
StringBuilder builder = new StringBuilder();
for (Iterator<JetSimpleNameExpression> iterator = header.getParentNamespaceNames().iterator(); iterator.hasNext(); ) {
JetSimpleNameExpression nameExpression = iterator.next();
builder.append(nameExpression.getReferencedName());
builder.append(".");
}
// PsiElement nameIdentifier = header.getNameIdentifier();
builder.append(header.getName());
return builder.toString();
}
public static String getFQName(JetClass jetClass) {
compiler/frontend/src/org/jetbrains/jet/JetNodeTypes.java
+1 -1
View File
@@ -142,5 +142,5 @@ public interface JetNodeTypes {
JetNodeType WHEN_CONDITION_IN_RANGE = new JetNodeType("WHEN_CONDITION_IN_RANGE", JetWhenConditionInRange.class);
JetNodeType WHEN_CONDITION_IS_PATTERN = new JetNodeType("WHEN_CONDITION_IS_PATTERN", JetWhenConditionIsPattern.class);
JetNodeType NAMESPACE_NAME = new JetNodeType("NAMESPACE_NAME", JetContainerNode.class);
JetNodeType NAMESPACE_HEADER = new JetNodeType("NAMESPACE_HEADER", JetNamespaceHeader.class);
}
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+27 -24
View File
@@ -35,26 +35,30 @@ public class JetControlFlowProcessor {
this.trace = trace;
}
public void generate(@NotNull JetDeclaration subroutineElement, @NotNull JetExpression body) {
generateSubroutineControlFlow(subroutineElement, Collections.singletonList(body));
}
public void generateSubroutineControlFlow(@NotNull JetDeclaration subroutineElement, @NotNull List<? extends JetElement> body) {
builder.enterSubroutine(subroutineElement);
for (JetElement statement : body) {
statement.accept(new CFPVisitor(false));
public void generate(@NotNull JetDeclaration subroutine) {
builder.enterSubroutine(subroutine);
if (subroutine instanceof JetDeclarationWithBody) {
JetDeclarationWithBody declarationWithBody = (JetDeclarationWithBody) subroutine;
CFPVisitor cfpVisitor = new CFPVisitor(false);
List<JetParameter> valueParameters = declarationWithBody.getValueParameters();
for (JetParameter valueParameter : valueParameters) {
valueParameter.accept(cfpVisitor);
}
JetExpression bodyExpression = declarationWithBody.getBodyExpression();
if (bodyExpression != null) {
bodyExpression.accept(cfpVisitor);
}
}
builder.exitSubroutine(subroutineElement);
else {
subroutine.accept(new CFPVisitor(false));
}
builder.exitSubroutine(subroutine);
}
private void processLocalDeclaration(@NotNull JetDeclaration subroutineElement, @NotNull JetExpression body) {
processLocalDeclaration(subroutineElement, Collections.singletonList(body));
}
private void processLocalDeclaration(@NotNull JetDeclaration subroutineElement, @NotNull List<? extends JetElement> body) {
private void processLocalDeclaration(@NotNull JetDeclaration subroutine) {
Label afterDeclaration = builder.createUnboundLabel();
builder.nondeterministicJump(afterDeclaration);
generateSubroutineControlFlow(subroutineElement, body);
generate(subroutine);
builder.bindLabel(afterDeclaration);
}
@@ -569,6 +573,12 @@ public class JetControlFlowProcessor {
}
}
@Override
public void visitParameter(JetParameter parameter) {
builder.declare(parameter);
builder.write(parameter, parameter);
}
@Override
public void visitBlockExpression(JetBlockExpression expression) {
List<JetElement> statements = expression.getStatements();
@@ -582,20 +592,13 @@ public class JetControlFlowProcessor {
@Override
public void visitNamedFunction(JetNamedFunction function) {
JetExpression bodyExpression = function.getBodyExpression();
if (bodyExpression != null) {
processLocalDeclaration(function, bodyExpression);
}
processLocalDeclaration(function);
}
@Override
public void visitFunctionLiteralExpression(JetFunctionLiteralExpression expression) {
JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
JetBlockExpression bodyExpression = functionLiteral.getBodyExpression();
if (bodyExpression != null) {
List<JetElement> statements = bodyExpression.getStatements();
processLocalDeclaration(functionLiteral, statements);
}
processLocalDeclaration(functionLiteral);
builder.read(expression);
}
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java
+19 -4
View File
@@ -19,6 +19,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.types.JetStandardClasses;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.plugin.JetMainDetector;
import java.util.*;
@@ -68,7 +69,7 @@ public class JetFlowInformationProvider {
}
};
JetControlFlowInstructionsGenerator instructionsGenerator = new JetControlFlowInstructionsGenerator(wrappedTrace);
new JetControlFlowProcessor(trace, instructionsGenerator).generate(declaration, bodyExpression);
new JetControlFlowProcessor(trace, instructionsGenerator).generate(declaration);
wrappedTrace.close();
}
@@ -479,13 +480,27 @@ public class JetFlowInformationProvider {
}
else if (instruction instanceof VariableDeclarationInstruction) {
JetDeclaration element = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement();
if (element instanceof JetProperty) {
if (element instanceof JetNamedDeclaration) {
PsiElement nameIdentifier = ((JetNamedDeclaration) element).getNameIdentifier();
PsiElement elementToMark = nameIdentifier != null ? nameIdentifier : element;
if (enterData.get(variableDescriptor) == VariableStatus.UNUSED) {
trace.report(Errors.UNUSED_VARIABLE.on((JetNamedDeclaration) element, elementToMark, variableDescriptor));
if (element instanceof JetProperty) {
trace.report(Errors.UNUSED_VARIABLE.on((JetProperty) element, elementToMark, variableDescriptor));
}
else if (element instanceof JetParameter) {
PsiElement psiElement = element.getParent().getParent();
if (psiElement instanceof JetFunction) {
boolean isMain = (psiElement instanceof JetNamedFunction) && JetMainDetector.isMain((JetNamedFunction) psiElement);
DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiElement);
assert descriptor instanceof FunctionDescriptor;
FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
if (!isMain && !functionDescriptor.getModality().isOverridable() && functionDescriptor.getOverriddenDescriptors().isEmpty()) {
trace.report(Errors.UNUSED_PARAMETER.on((JetParameter) element, elementToMark, variableDescriptor));
}
}
}
}
else if (enterData.get(variableDescriptor) == VariableStatus.WRITTEN) {
else if (enterData.get(variableDescriptor) == VariableStatus.WRITTEN && element instanceof JetProperty) {
trace.report(Errors.ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE.on((JetNamedDeclaration) element, elementToMark, variableDescriptor));
}
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorImpl.java
+7 -1
View File
@@ -46,6 +46,12 @@ public abstract class DeclarationDescriptorImpl extends AnnotatedImpl implements
@Override
public String toString() {
return DescriptorRenderer.TEXT.render(this) + "[" + getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(this)) + "]";
try {
return DescriptorRenderer.TEXT.render(this) + "[" + getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(this)) + "]";
} catch (Throwable e) {
// DescriptionRenderer may throw if this is not yet completely initialized
// It is very inconvenient while debugging
return super.toString();
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java
+2 -2
View File
@@ -83,10 +83,10 @@ public class FunctionDescriptorUtil {
return parameterScope;
}
public static void initializeFromFunctionType(@NotNull FunctionDescriptorImpl functionDescriptor, @NotNull JetType functionType) {
public static void initializeFromFunctionType(@NotNull FunctionDescriptorImpl functionDescriptor, @NotNull JetType functionType, @NotNull ReceiverDescriptor expectedThisObject) {
assert JetStandardClasses.isFunctionType(functionType);
functionDescriptor.initialize(JetStandardClasses.getReceiverType(functionType),
ReceiverDescriptor.NO_RECEIVER,
expectedThisObject,
Collections.<TypeParameterDescriptor>emptyList(),
JetStandardClasses.getValueParameters(functionDescriptor, functionType),
JetStandardClasses.getReturnTypeFromFunctionType(functionType),
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
+10
View File
@@ -118,6 +118,16 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab
return getOutType();
}
@Override
public JetType getInType() {
return super.getInType();
}
@Override
@NotNull
public JetType getOutType() {
return super.getOutType();
}
public boolean isVar() {
return isVar;
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java
+1 -1
View File
@@ -14,7 +14,7 @@ public class VariableAsFunctionDescriptor extends FunctionDescriptorImpl {
JetType outType = variableDescriptor.getOutType();
assert outType != null;
VariableAsFunctionDescriptor result = new VariableAsFunctionDescriptor(variableDescriptor);
FunctionDescriptorUtil.initializeFromFunctionType(result, outType);
FunctionDescriptorUtil.initializeFromFunctionType(result, outType, variableDescriptor.getExpectedThisObject());
return result;
}
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
+3 -2
View File
@@ -147,8 +147,9 @@ public interface Errors {
PsiElementOnlyDiagnosticFactory3<JetModifierListOwner, CallableMemberDescriptor, CallableMemberDescriptor, DeclarationDescriptor> VIRTUAL_MEMBER_HIDDEN = PsiElementOnlyDiagnosticFactory3.create(ERROR, "''{0}'' hides ''{1}'' in class {2} and needs 'override' modifier", DescriptorRenderer.TEXT);
PsiElementOnlyDiagnosticFactory1<JetSimpleNameExpression, DeclarationDescriptor> UNINITIALIZED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Variable ''{0}'' must be initialized", NAME);
PsiElementOnlyDiagnosticFactory1<JetNamedDeclaration, DeclarationDescriptor> UNUSED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Variable ''{0}'' is never used", NAME);
PsiElementOnlyDiagnosticFactory1<JetNamedDeclaration, DeclarationDescriptor> ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE = PsiElementOnlyDiagnosticFactory1.create(WARNING, "Variable ''{0}'' is assigned but never accessed", NAME);
UnusedElementDiagnosticFactory<JetProperty, VariableDescriptor> UNUSED_VARIABLE = UnusedElementDiagnosticFactory.create(WARNING, "Variable ''{0}'' is never used", NAME);
UnusedElementDiagnosticFactory<JetParameter, VariableDescriptor> UNUSED_PARAMETER = UnusedElementDiagnosticFactory.create(WARNING, "Parameter ''{0}'' is never used", NAME);
UnusedElementDiagnosticFactory<JetNamedDeclaration, DeclarationDescriptor> ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE = UnusedElementDiagnosticFactory.create(WARNING, "Variable ''{0}'' is assigned but never accessed", NAME);
PsiElementOnlyDiagnosticFactory2<JetElement, JetElement, DeclarationDescriptor> UNUSED_VALUE = new PsiElementOnlyDiagnosticFactory2<JetElement, JetElement, DeclarationDescriptor>(WARNING, "The value ''{0}'' assigned to ''{1}'' is never used", NAME) {
@Override
protected String makeMessageForA(@NotNull JetElement element) {
compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/UnusedElementDiagnosticFactory.java
+23
View File
@@ -0,0 +1,23 @@
package org.jetbrains.jet.lang.diagnostics;
import com.intellij.psi.PsiElement;
/**
* @author svtk
*/
public class UnusedElementDiagnosticFactory<T extends PsiElement, A> extends PsiElementOnlyDiagnosticFactory1<T, A> {
public static <T extends PsiElement, A> UnusedElementDiagnosticFactory<T, A> create(Severity severity, String messageStub) {
return new UnusedElementDiagnosticFactory<T, A>(severity, messageStub);
}
public static <T extends PsiElement, A> UnusedElementDiagnosticFactory<T, A> create(Severity severity, String messageStub, Renderer renderer) {
return new UnusedElementDiagnosticFactory<T, A>(severity, messageStub, renderer);
}
public UnusedElementDiagnosticFactory(Severity severity, String message, Renderer renderer) {
super(severity, message, renderer);
}
protected UnusedElementDiagnosticFactory(Severity severity, String message) {
super(severity, message);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/parsing/JetParsing.java
+15 -5
View File
@@ -115,17 +115,18 @@ public class JetParsing extends AbstractJetParsing {
* : modifiers "namespace" SimpleName{"."} SEMI?
* ;
*/
PsiBuilder.Marker namespaceHeader = mark();
PsiBuilder.Marker firstEntry = mark();
parseModifierList(MODIFIER_LIST, true);
if (at(NAMESPACE_KEYWORD)) {
advance(); // NAMESPACE_KEYWORD
parseNamespaceName();
if (at(LBRACE)) {
// Because it's blocked namespace and it will be parsed as one of top level objects
firstEntry.rollbackTo();
namespaceHeader.done(NAMESPACE_HEADER);
return;
}
@@ -135,6 +136,7 @@ public class JetParsing extends AbstractJetParsing {
} else {
firstEntry.rollbackTo();
}
namespaceHeader.done(NAMESPACE_HEADER);
// TODO: Duplicate with parsing imports in parseToplevelDeclarations
while (at(IMPORT_KEYWORD)) {
@@ -145,12 +147,18 @@ public class JetParsing extends AbstractJetParsing {
/* SimpleName{"."} */
private void parseNamespaceName() {
PsiBuilder.Marker nsName = mark();
expect(IDENTIFIER, "Expecting qualified name", NAMESPACE_NAME_RECOVERY_SET);
while (!eol() && at(DOT)) {
advance(); // DOT
while (true) {
expect(IDENTIFIER, "Namespace name must be a '.'-separated identifier list", NAMESPACE_NAME_RECOVERY_SET);
if (at(DOT)) {
nsName.done(REFERENCE_EXPRESSION);
advance(); // DOT
nsName = mark();
}
else {
nsName.drop();
break;
}
}
nsName.done(NAMESPACE_NAME);
}
/*
@@ -378,6 +386,7 @@ public class JetParsing extends AbstractJetParsing {
*/
private JetNodeType parseNamespaceBlock() {
assert _at(NAMESPACE_KEYWORD);
PsiBuilder.Marker namespaceHeader = mark();
advance(); // NAMESPACE_KEYWORD
if (at(LBRACE)) {
@@ -386,6 +395,7 @@ public class JetParsing extends AbstractJetParsing {
else {
parseNamespaceName();
}
namespaceHeader.done(NAMESPACE_HEADER);
if (!at(LBRACE)) {
error("A namespace block in '{...}' expected");
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotatedExpression.java
+2
View File
@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.psi;
import com.intellij.lang.ASTNode;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.JetNodeTypes;
import java.util.ArrayList;
@@ -26,6 +27,7 @@ public class JetAnnotatedExpression extends JetExpression {
return visitor.visitAnnotatedExpression(this, data);
}
@Nullable
public JetExpression getBaseExpression() {
return findChildByClass(JetExpression.class);
}
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespace.java
+9 -4
View File
@@ -39,18 +39,23 @@ public class JetNamespace extends JetNamedDeclaration {
}
public String getName() {
PsiElement nameIdentifier = getNameIdentifier();
return nameIdentifier != null ? nameIdentifier.getText() : "";
String name = super.getName();
return name == null ? "" : name;
}
@NotNull
public JetNamespaceHeader getHeader() {
return (JetNamespaceHeader) findChildByType(JetNodeTypes.NAMESPACE_HEADER);
}
@Override
public PsiElement getNameIdentifier() {
return findChildByType(JetNodeTypes.NAMESPACE_NAME);
return getHeader().getNameIdentifier();
}
@Override
public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
throw new UnsupportedOperationException(); // TODO
throw new UnsupportedOperationException();
}
}
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceHeader.java
+35
View File
@@ -0,0 +1,35 @@
package org.jetbrains.jet.lang.psi;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.JetNodeTypes;
import org.jetbrains.jet.lexer.JetTokens;
import java.util.List;
/**
* @author abreslav
*/
public class JetNamespaceHeader extends JetElement {
public JetNamespaceHeader(@NotNull ASTNode node) {
super(node);
}
@NotNull
public List<JetSimpleNameExpression> getParentNamespaceNames() {
return findChildrenByType(JetNodeTypes.REFERENCE_EXPRESSION);
}
@Nullable
public PsiElement getNameIdentifier() {
return findChildByType(JetTokens.IDENTIFIER);
}
@Override
public String getName() {
PsiElement nameIdentifier = getNameIdentifier();
return nameIdentifier == null ? "" : nameIdentifier.getText();
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java
+4
View File
@@ -5,6 +5,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableAsFunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.types.JetType;
@@ -43,6 +44,9 @@ public class BindingContextUtils {
if (descriptor instanceof VariableDescriptor) {
return (VariableDescriptor) descriptor;
}
if (descriptor instanceof VariableAsFunctionDescriptor) {
return ((VariableAsFunctionDescriptor) descriptor).getVariableDescriptor();
}
return null;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+30 -13
View File
@@ -69,19 +69,7 @@ public class TypeHierarchyResolver {
declaration.accept(new JetVisitorVoid() {
@Override
public void visitNamespace(JetNamespace namespace) {
String name = JetPsiUtil.safeName(namespace.getName());
NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
if (namespaceDescriptor == null) {
namespaceDescriptor = new NamespaceDescriptorImpl(
owner.getOriginal(),
Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
name
);
namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"));
owner.addNamespace(namespaceDescriptor);
context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
}
NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorPathIfNeeded(namespace, owner);
context.getNamespaceDescriptors().put(namespace, namespaceDescriptor);
WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), new TraceBasedRedeclarationHandler(context.getTrace()));
@@ -202,6 +190,35 @@ public class TypeHierarchyResolver {
}
}
private NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(JetNamespace namespace, NamespaceLike owner) {
NamespaceLike currentOwner = owner;
for (JetSimpleNameExpression nameExpression : namespace.getHeader().getParentNamespaceNames()) {
currentOwner = createNamespaceDescriptorIfNeeded(null, currentOwner, JetPsiUtil.safeName(nameExpression.getReferencedName()));
context.getTrace().record(REFERENCE_TARGET, nameExpression, currentOwner);
}
String name = JetPsiUtil.safeName(namespace.getName());
return createNamespaceDescriptorIfNeeded(namespace, currentOwner, name);
}
@NotNull
private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetNamespace namespace, @NotNull NamespaceLike owner, @NotNull String name) {
NamespaceDescriptorImpl namespaceDescriptor = owner.getNamespace(name);
if (namespaceDescriptor == null) {
namespaceDescriptor = new NamespaceDescriptorImpl(
owner.getOriginal(),
Collections.<AnnotationDescriptor>emptyList(), // TODO: annotations
name
);
namespaceDescriptor.initialize(new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, new TraceBasedRedeclarationHandler(context.getTrace())).setDebugName("Namespace member scope"));
owner.addNamespace(namespaceDescriptor);
if (namespace != null) {
context.getTrace().record(BindingContext.NAMESPACE, namespace, namespaceDescriptor);
}
}
return namespaceDescriptor;
}
@NotNull
private ClassKind getClassKind(@NotNull JetClass jetClass) {
if (jetClass.isTrait()) return ClassKind.TRAIT;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
+1 -1
View File
@@ -185,7 +185,7 @@ public class CallResolver {
}
FunctionDescriptorImpl functionDescriptor = new ExpressionAsFunctionDescriptor(scope.getContainingDeclaration(), "[for expression " + calleeExpression.getText() + "]");
FunctionDescriptorUtil.initializeFromFunctionType(functionDescriptor, calleeType);
FunctionDescriptorUtil.initializeFromFunctionType(functionDescriptor, calleeType, NO_RECEIVER);
ResolvedCallImpl<FunctionDescriptor> resolvedCall = ResolvedCallImpl.<FunctionDescriptor>create(functionDescriptor);
resolvedCall.setReceiverArgument(call.getExplicitReceiver());
prioritizedTasks = Collections.singletonList(new ResolutionTask<FunctionDescriptor>(
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
+2 -14
View File
@@ -64,20 +64,8 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
scope = explicitReceiver.getType().getMemberScope();
explicitReceiver = NO_RECEIVER;
}
doComputeTasks(scope, explicitReceiver, call, name, result, AutoCastService.NO_AUTO_CASTS);
doComputeTasks(scope, explicitReceiver, call, name, result, new AutoCastServiceImpl(dataFlowInfo, bindingContext));
List<ReceiverDescriptor> receivers;
if (explicitReceiver.exists()) {
receivers = Collections.singletonList(explicitReceiver);
}
else {
receivers = Lists.newArrayList();
scope.getImplicitReceiversHierarchy(receivers);
}
for (ReceiverDescriptor receiverToCast : receivers) {
assert receiverToCast.exists();
doComputeTasks(scope, receiverToCast, call, name, result, new AutoCastServiceImpl(dataFlowInfo, bindingContext));
}
return result;
}
@@ -87,7 +75,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
scope.getImplicitReceiversHierarchy(implicitReceivers);
if (receiver.exists()) {
List<ReceiverDescriptor> variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver);
Collection<ResolvedCallImpl<D>> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, getExtensionsByName(scope, name));
List<ResolvedCallImpl<D>> nonlocals = Lists.newArrayList();
List<ResolvedCallImpl<D>> locals = Lists.newArrayList();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastServiceImpl.java
+4 -1
View File
@@ -1,5 +1,6 @@
package org.jetbrains.jet.lang.resolve.calls.autocasts;
import com.google.common.collect.Lists;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
@@ -21,7 +22,9 @@ public class AutoCastServiceImpl implements AutoCastService {
@NotNull
@Override
public List<ReceiverDescriptor> getVariantsForReceiver(@NotNull ReceiverDescriptor receiverDescriptor) {
return AutoCastUtils.getAutoCastVariants(bindingContext, dataFlowInfo, receiverDescriptor);
List<ReceiverDescriptor> variants = Lists.newArrayList(AutoCastUtils.getAutoCastVariants(bindingContext, dataFlowInfo, receiverDescriptor));
variants.add(receiverDescriptor);
return variants;
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java
+3
View File
@@ -17,6 +17,9 @@ public class AutoCastUtils {
private AutoCastUtils() {}
/**
* @return variants @param receiverToCast may be cast to according to @param dataFlowInfo, @param receiverToCast itself is NOT included
*/
public static List<ReceiverDescriptor> getAutoCastVariants(@NotNull final BindingContext bindingContext, @NotNull final DataFlowInfo dataFlowInfo, @NotNull ReceiverDescriptor receiverToCast) {
return receiverToCast.accept(new ReceiverDescriptorVisitor<List<ReceiverDescriptor>, Object>() {
@Override
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java
+1 -1
View File
@@ -102,7 +102,7 @@ public class DataFlowInfo {
boolean changed = false;
changed |= putNullability(builder, a, nullabilityOfA.refine(nullabilityOfB.invert()));
changed |= putNullability(builder, b, nullabilityOfA.refine(nullabilityOfA.invert()));
changed |= putNullability(builder, b, nullabilityOfB.refine(nullabilityOfA.invert()));
return changed ? new DataFlowInfo(ImmutableMap.copyOf(builder), typeInfo) : this;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java
+2 -1
View File
@@ -250,7 +250,8 @@ public class CompileTimeConstantResolver {
if (error != null) {
return error;
}
return new StringValue(unescapedText);
return new StringValue(unescapedText.substring(3, unescapedText.length() - 3));
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java
+8
View File
@@ -299,11 +299,19 @@ public class WritableScopeImpl extends WritableScopeWithImports {
@Override
public void addPropertyDescriptorByFieldName(@NotNull String fieldName, @NotNull PropertyDescriptor propertyDescriptor) {
if (!fieldName.startsWith("$")) {
throw new IllegalStateException();
}
getPropertyDescriptorsByFieldNames().put(fieldName, propertyDescriptor);
}
@Override
public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) {
if (!fieldName.startsWith("$")) {
throw new IllegalStateException();
}
PropertyDescriptor descriptor = getPropertyDescriptorsByFieldNames().get(fieldName);
if (descriptor != null) return descriptor;
return super.getPropertyByFieldReference(fieldName);
compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java
+1 -5
View File
@@ -1,7 +1,6 @@
package org.jetbrains.jet.lang.types.expressions;
import com.intellij.lang.ASTNode;
import com.intellij.util.Function;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.psi.*;
@@ -14,7 +13,6 @@ import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException;
import static org.jetbrains.jet.lang.diagnostics.Errors.ELSE_MISPLACED_IN_WHEN;
import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM;
/**
@@ -22,11 +20,9 @@ import static org.jetbrains.jet.lang.diagnostics.Errors.TYPECHECKER_HAS_RUN_INTO
*/
public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetType, ExpressionTypingContext> implements ExpressionTypingInternals {
private static ExpressionTypingVisitorDispatcher BASIC_DISPATCHER = new ExpressionTypingVisitorDispatcher(null);
@NotNull
public static ExpressionTypingFacade create() {
return BASIC_DISPATCHER;
return new ExpressionTypingVisitorDispatcher(null);
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/types/inference/ConstraintSystemImpl.java
+51 -22
View File
@@ -73,9 +73,11 @@ public class ConstraintSystemImpl implements ConstraintSystem {
@Nullable
public abstract KnownType getValue();
public abstract boolean equate(TypeValue other);
}
private static class UnknownType extends TypeValue {
private class UnknownType extends TypeValue {
private final TypeParameterDescriptor typeParameterDescriptor;
private final Variance positionVariance;
@@ -87,6 +89,24 @@ public class ConstraintSystemImpl implements ConstraintSystem {
this.positionVariance = positionVariance;
}
@Override
public void addUpperBound(@NotNull TypeValue bound) {
addBound(bound, getLowerBounds());
super.addUpperBound(bound);
}
@Override
public void addLowerBound(@NotNull TypeValue bound) {
addBound(bound, getUpperBounds());
super.addLowerBound(bound);
}
private void addBound(TypeValue bound, Set<TypeValue> oppositeBounds) {
if (oppositeBounds.contains(bound)) {
this.equate(bound);
}
}
@NotNull
public TypeParameterDescriptor getTypeParameterDescriptor() {
return typeParameterDescriptor;
@@ -139,6 +159,18 @@ public class ConstraintSystemImpl implements ConstraintSystem {
return value;
}
@Override
public boolean equate(TypeValue other) {
if (other instanceof KnownType) {
KnownType knownType = (KnownType) other;
return setValue(knownType);
}
assert other instanceof UnknownType;
mergeUnknowns((UnknownType) other, this);
return true;
}
public boolean setValue(@NotNull KnownType value) {
if (this.value != null) {
// If we have already assigned a value to this unknown,
@@ -186,6 +218,15 @@ public class ConstraintSystemImpl implements ConstraintSystem {
public String toString() {
return type.toString();
}
@Override
public boolean equate(TypeValue other) {
if (other instanceof KnownType) {
KnownType knownType = (KnownType) other;
return TypeUtils.equalTypes(type, knownType.getType());
}
return other.equate(this);
}
}
private final Map<JetType, KnownType> knownTypes = Maps.newHashMap();
@@ -233,25 +274,7 @@ public class ConstraintSystemImpl implements ConstraintSystem {
TypeValue aValue = getTypeValueFor(a);
TypeValue bValue = getTypeValueFor(b);
if (aValue instanceof UnknownType) {
UnknownType aUnknown = (UnknownType) aValue;
if (bValue instanceof UnknownType) {
UnknownType bUnknown = (UnknownType) bValue;
mergeUnknowns(aUnknown, bUnknown);
}
else {
if (!aUnknown.setValue((KnownType) bValue)) return false;
}
}
else if (bValue instanceof UnknownType) {
UnknownType bUnknown = (UnknownType) bValue;
if (!bUnknown.setValue((KnownType) aValue)) return false;
}
else {
return TypeUtils.equalTypes(a, b);
}
return true;
return aValue.equate(bValue);
}
@Override
@@ -267,9 +290,15 @@ public class ConstraintSystemImpl implements ConstraintSystem {
@Override
public boolean noCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype) {
// If some of the types is an unknown, the constraint is already generated, and we should carry on
// If some of the types is an unknown, the constraint must be generated, and we should carry on
// otherwise there can be no solution, and we should fail
return someUnknown(getTypeValueFor(subtype), getTypeValueFor(supertype));
TypeValue subTypeValue = getTypeValueFor(subtype);
TypeValue superTypeValue = getTypeValueFor(supertype);
boolean someUnknown = someUnknown(subTypeValue, superTypeValue);
if (someUnknown) {
addSubtypingConstraintOnTypeValues(subTypeValue, superTypeValue);
}
return someUnknown;
}
private boolean someUnknown(TypeValue subtypeValue, TypeValue supertypeValue) {
compiler/frontend/src/org/jetbrains/jet/plugin/JetMainDetector.java
+13 -10
View File
@@ -17,17 +17,20 @@ public class JetMainDetector {
public static boolean hasMain(List<JetDeclaration> declarations) {
for (JetDeclaration declaration : declarations) {
if (declaration instanceof JetNamedFunction) {
JetNamedFunction function = (JetNamedFunction) declaration;
if ("main".equals(function.getName())) {
List<JetParameter> parameters = function.getValueParameters();
if (parameters.size() == 1) {
JetTypeReference reference = parameters.get(0).getTypeReference();
if (reference != null && reference.getText().equals("Array<String>")) { // TODO correct check
return true;
}
}
}
if (isMain((JetNamedFunction) declaration)) return true;
}
}
return false;
}
public static boolean isMain(JetNamedFunction function) {
if ("main".equals(function.getName())) {
List<JetParameter> parameters = function.getValueParameters();
if (parameters.size() == 1) {
JetTypeReference reference = parameters.get(0).getTypeReference();
if (reference != null && reference.getText().equals("Array<String>")) { // TODO correct check
return true;
}
}
}
return false;
compiler/testData/cfg/Basic.instructions
+20 -12
View File
@@ -31,8 +31,10 @@ fun f(a : Boolean) : Unit {
}
---------------------
l0:
<START> NEXT:[r(1)] PREV:[]
r(1) NEXT:[r(a)] PREV:[<START>]
<START> NEXT:[v(a : Boolean)] PREV:[]
v(a : Boolean) NEXT:[w(a)] PREV:[<START>]
w(a) NEXT:[r(1)] PREV:[v(a : Boolean)]
r(1) NEXT:[r(a)] PREV:[w(a)]
r(a) NEXT:[r(2)] PREV:[r(1)]
r(2) NEXT:[r(lng)] PREV:[r(a)]
r(lng) NEXT:[r(2.lng)] PREV:[r(2)]
@@ -92,14 +94,18 @@ sink:
fun foo(a : Boolean, b : Int) : Unit {}
---------------------
l0:
<START> NEXT:[read (Unit)] PREV:[]
read (Unit) NEXT:[<END>] PREV:[<START>]
<START> NEXT:[v(a : Boolean)] PREV:[]
v(a : Boolean) NEXT:[w(a)] PREV:[<START>]
w(a) NEXT:[v(b : Int)] PREV:[v(a : Boolean)]
v(b : Int) NEXT:[w(b)] PREV:[w(a)]
w(b) NEXT:[read (Unit)] PREV:[v(b : Int)]
read (Unit) NEXT:[<END>] PREV:[w(b)]
l1:
<END> NEXT:[<SINK>] PREV:[read (Unit)]
<END> NEXT:[<SINK>] PREV:[read (Unit)]
error:
<ERROR> NEXT:[] PREV:[]
<ERROR> NEXT:[] PREV:[]
sink:
<SINK> NEXT:[] PREV:[<END>]
<SINK> NEXT:[] PREV:[<END>]
=====================
== genfun ==
fun genfun<T>() : Unit {}
@@ -118,12 +124,14 @@ sink:
fun flfun(f : fun () : Any) : Unit {}
---------------------
l0:
<START> NEXT:[read (Unit)] PREV:[]
read (Unit) NEXT:[<END>] PREV:[<START>]
<START> NEXT:[v(f : fun () : Any)] PREV:[]
v(f : fun () : Any) NEXT:[w(f)] PREV:[<START>]
w(f) NEXT:[read (Unit)] PREV:[v(f : fun () : Any)]
read (Unit) NEXT:[<END>] PREV:[w(f)]
l1:
<END> NEXT:[<SINK>] PREV:[read (Unit)]
<END> NEXT:[<SINK>] PREV:[read (Unit)]
error:
<ERROR> NEXT:[] PREV:[]
<ERROR> NEXT:[] PREV:[]
sink:
<SINK> NEXT:[] PREV:[<END>]
<SINK> NEXT:[] PREV:[<END>]
=====================
compiler/testData/cfg/Finally.instructions
+16 -8
View File
@@ -388,8 +388,10 @@ fun t8(a : Int) {
}
---------------------
l0:
<START> NEXT:[r(1)] PREV:[]
r(1) NEXT:[r(a)] PREV:[<START>]
<START> NEXT:[v(a : Int)] PREV:[]
v(a : Int) NEXT:[w(a)] PREV:[<START>]
w(a) NEXT:[r(1)] PREV:[v(a : Int)]
r(1) NEXT:[r(a)] PREV:[w(a)]
r(a) NEXT:[r(..)] PREV:[r(1)]
r(..) NEXT:[r(1..a)] PREV:[r(a)]
r(1..a) NEXT:[v(i)] PREV:[r(..)]
@@ -439,8 +441,10 @@ fun t9(a : Int) {
}
---------------------
l0:
<START> NEXT:[r(1)] PREV:[]
r(1) NEXT:[r(a)] PREV:[<START>]
<START> NEXT:[v(a : Int)] PREV:[]
v(a : Int) NEXT:[w(a)] PREV:[<START>]
w(a) NEXT:[r(1)] PREV:[v(a : Int)]
r(1) NEXT:[r(a)] PREV:[w(a)]
r(a) NEXT:[r(..)] PREV:[r(1)]
r(..) NEXT:[r(1..a)] PREV:[r(a)]
r(1..a) NEXT:[v(i)] PREV:[r(..)]
@@ -489,8 +493,10 @@ fun t10(a : Int) {
}
---------------------
l0:
<START> NEXT:[r(1)] PREV:[]
r(1) NEXT:[r(a)] PREV:[<START>]
<START> NEXT:[v(a : Int)] PREV:[]
v(a : Int) NEXT:[w(a)] PREV:[<START>]
w(a) NEXT:[r(1)] PREV:[v(a : Int)]
r(1) NEXT:[r(a)] PREV:[w(a)]
r(a) NEXT:[r(..)] PREV:[r(1)]
r(..) NEXT:[r(1..a)] PREV:[r(a)]
r(1..a) NEXT:[v(i)] PREV:[r(..)]
@@ -747,8 +753,10 @@ fun doSmth(i: Int) {
}
---------------------
l0:
<START> NEXT:[read (Unit)] PREV:[]
read (Unit) NEXT:[<END>] PREV:[<START>]
<START> NEXT:[v(i: Int)] PREV:[]
v(i: Int) NEXT:[w(i)] PREV:[<START>]
w(i) NEXT:[read (Unit)] PREV:[v(i: Int)]
read (Unit) NEXT:[<END>] PREV:[w(i)]
l1:
<END> NEXT:[<SINK>] PREV:[read (Unit)]
error:
compiler/testData/cfg/For.instructions
+4 -2
View File
@@ -34,8 +34,10 @@ sink:
fun doSmth(i: Int) {}
---------------------
l0:
<START> NEXT:[read (Unit)] PREV:[]
read (Unit) NEXT:[<END>] PREV:[<START>]
<START> NEXT:[v(i: Int)] PREV:[]
v(i: Int) NEXT:[w(i)] PREV:[<START>]
w(i) NEXT:[read (Unit)] PREV:[v(i: Int)]
read (Unit) NEXT:[<END>] PREV:[w(i)]
l1:
<END> NEXT:[<SINK>] PREV:[read (Unit)]
error:
compiler/testData/cfg/If.instructions
+34 -28
View File
@@ -17,8 +17,10 @@ fun t1(b: Boolean) {
}
---------------------
l0:
<START> NEXT:[v(var u: String)] PREV:[]
v(var u: String) NEXT:[r(b)] PREV:[<START>]
<START> NEXT:[v(b: Boolean)] PREV:[]
v(b: Boolean) NEXT:[w(b)] PREV:[<START>]
w(b) NEXT:[v(var u: String)] PREV:[v(b: Boolean)]
v(var u: String) NEXT:[r(b)] PREV:[w(b)]
r(b) NEXT:[jf(l2)] PREV:[v(var u: String)]
jf(l2) NEXT:[read (Unit), r("s")] PREV:[r(b)]
r("s") NEXT:[w(u)] PREV:[jf(l2)]
@@ -63,45 +65,49 @@ fun t2(b: Boolean) {
}
---------------------
l0:
<START> NEXT:[v(val i = 3)] PREV:[]
v(val i = 3) NEXT:[r(3)] PREV:[<START>]
r(3) NEXT:[w(i)] PREV:[v(val i = 3)]
w(i) NEXT:[r(b)] PREV:[r(3)]
r(b) NEXT:[jf(l2)] PREV:[w(i)]
jf(l2) NEXT:[read (Unit), ret l1] PREV:[r(b)]
ret l1 NEXT:[<END>] PREV:[jf(l2)]
* jmp(l3) NEXT:[r(i)] PREV:[]
<START> NEXT:[v(b: Boolean)] PREV:[]
v(b: Boolean) NEXT:[w(b)] PREV:[<START>]
w(b) NEXT:[v(val i = 3)] PREV:[v(b: Boolean)]
v(val i = 3) NEXT:[r(3)] PREV:[w(b)]
r(3) NEXT:[w(i)] PREV:[v(val i = 3)]
w(i) NEXT:[r(b)] PREV:[r(3)]
r(b) NEXT:[jf(l2)] PREV:[w(i)]
jf(l2) NEXT:[read (Unit), ret l1] PREV:[r(b)]
ret l1 NEXT:[<END>] PREV:[jf(l2)]
* jmp(l3) NEXT:[r(i)] PREV:[]
l2:
read (Unit) NEXT:[r(i)] PREV:[jf(l2)]
read (Unit) NEXT:[r(i)] PREV:[jf(l2)]
l3:
r(i) NEXT:[r(doSmth)] PREV:[read (Unit)]
r(doSmth) NEXT:[r(doSmth(i))] PREV:[r(i)]
r(doSmth(i)) NEXT:[r(i)] PREV:[r(doSmth)]
r(i) NEXT:[r(i is Int)] PREV:[r(doSmth(i))]
r(i is Int) NEXT:[jf(l4)] PREV:[r(i)]
jf(l4) NEXT:[read (Unit), ret l1] PREV:[r(i is Int)]
ret l1 NEXT:[<END>] PREV:[jf(l4)]
* jmp(l5) NEXT:[<END>] PREV:[]
r(i) NEXT:[r(doSmth)] PREV:[read (Unit)]
r(doSmth) NEXT:[r(doSmth(i))] PREV:[r(i)]
r(doSmth(i)) NEXT:[r(i)] PREV:[r(doSmth)]
r(i) NEXT:[r(i is Int)] PREV:[r(doSmth(i))]
r(i is Int) NEXT:[jf(l4)] PREV:[r(i)]
jf(l4) NEXT:[read (Unit), ret l1] PREV:[r(i is Int)]
ret l1 NEXT:[<END>] PREV:[jf(l4)]
* jmp(l5) NEXT:[<END>] PREV:[]
l4:
read (Unit) NEXT:[<END>] PREV:[jf(l4)]
read (Unit) NEXT:[<END>] PREV:[jf(l4)]
l1:
l5:
<END> NEXT:[<SINK>] PREV:[ret l1, ret l1, read (Unit)]
<END> NEXT:[<SINK>] PREV:[ret l1, ret l1, read (Unit)]
error:
<ERROR> NEXT:[] PREV:[]
<ERROR> NEXT:[] PREV:[]
sink:
<SINK> NEXT:[] PREV:[<END>]
<SINK> NEXT:[] PREV:[<END>]
=====================
== doSmth ==
fun doSmth(s: String) {}
---------------------
l0:
<START> NEXT:[read (Unit)] PREV:[]
read (Unit) NEXT:[<END>] PREV:[<START>]
<START> NEXT:[v(s: String)] PREV:[]
v(s: String) NEXT:[w(s)] PREV:[<START>]
w(s) NEXT:[read (Unit)] PREV:[v(s: String)]
read (Unit) NEXT:[<END>] PREV:[w(s)]
l1:
<END> NEXT:[<SINK>] PREV:[read (Unit)]
<END> NEXT:[<SINK>] PREV:[read (Unit)]
error:
<ERROR> NEXT:[] PREV:[]
<ERROR> NEXT:[] PREV:[]
sink:
<SINK> NEXT:[] PREV:[<END>]
<SINK> NEXT:[] PREV:[<END>]
=====================
compiler/testData/cfg/LazyBooleans.instructions
+42 -38
View File
@@ -18,57 +18,61 @@ fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
}
---------------------
l0:
<START> NEXT:[r(a)] PREV:[]
r(a) NEXT:[jf(l2)] PREV:[<START>]
jf(l2) NEXT:[r(2), r(1)] PREV:[r(a)]
r(1) NEXT:[jmp(l3)] PREV:[jf(l2)]
jmp(l3) NEXT:[r(3)] PREV:[r(1)]
<START> NEXT:[v(a : Boolean)] PREV:[]
v(a : Boolean) NEXT:[w(a)] PREV:[<START>]
w(a) NEXT:[v(b : Boolean)] PREV:[v(a : Boolean)]
v(b : Boolean) NEXT:[w(b)] PREV:[w(a)]
w(b) NEXT:[r(a)] PREV:[v(b : Boolean)]
r(a) NEXT:[jf(l2)] PREV:[w(b)]
jf(l2) NEXT:[r(2), r(1)] PREV:[r(a)]
r(1) NEXT:[jmp(l3)] PREV:[jf(l2)]
jmp(l3) NEXT:[r(3)] PREV:[r(1)]
l2:
r(2) NEXT:[r(3)] PREV:[jf(l2)]
r(2) NEXT:[r(3)] PREV:[jf(l2)]
l3:
r(3) NEXT:[r(a)] PREV:[jmp(l3), r(2)]
r(a) NEXT:[jf(l4)] PREV:[r(3)]
jf(l4) NEXT:[jf(l5), r(b)] PREV:[r(a)]
r(b) NEXT:[jf(l5)] PREV:[jf(l4)]
r(3) NEXT:[r(a)] PREV:[jmp(l3), r(2)]
r(a) NEXT:[jf(l4)] PREV:[r(3)]
jf(l4) NEXT:[jf(l5), r(b)] PREV:[r(a)]
r(b) NEXT:[jf(l5)] PREV:[jf(l4)]
l4:
jf(l5) NEXT:[r(6), r(5)] PREV:[jf(l4), r(b)]
r(5) NEXT:[jmp(l6)] PREV:[jf(l5)]
jmp(l6) NEXT:[r(7)] PREV:[r(5)]
jf(l5) NEXT:[r(6), r(5)] PREV:[jf(l4), r(b)]
r(5) NEXT:[jmp(l6)] PREV:[jf(l5)]
jmp(l6) NEXT:[r(7)] PREV:[r(5)]
l5:
r(6) NEXT:[r(7)] PREV:[jf(l5)]
r(6) NEXT:[r(7)] PREV:[jf(l5)]
l6:
r(7) NEXT:[r(a)] PREV:[jmp(l6), r(6)]
r(a) NEXT:[jt(l7)] PREV:[r(7)]
jt(l7) NEXT:[r(b), jf(l8)] PREV:[r(a)]
r(b) NEXT:[jf(l8)] PREV:[jt(l7)]
r(7) NEXT:[r(a)] PREV:[jmp(l6), r(6)]
r(a) NEXT:[jt(l7)] PREV:[r(7)]
jt(l7) NEXT:[r(b), jf(l8)] PREV:[r(a)]
r(b) NEXT:[jf(l8)] PREV:[jt(l7)]
l7:
jf(l8) NEXT:[r(9), r(8)] PREV:[jt(l7), r(b)]
r(8) NEXT:[jmp(l9)] PREV:[jf(l8)]
jmp(l9) NEXT:[r(10)] PREV:[r(8)]
jf(l8) NEXT:[r(9), r(8)] PREV:[jt(l7), r(b)]
r(8) NEXT:[jmp(l9)] PREV:[jf(l8)]
jmp(l9) NEXT:[r(10)] PREV:[r(8)]
l8:
r(9) NEXT:[r(10)] PREV:[jf(l8)]
r(9) NEXT:[r(10)] PREV:[jf(l8)]
l9:
r(10) NEXT:[r(a)] PREV:[jmp(l9), r(9)]
r(a) NEXT:[jf(l10)] PREV:[r(10)]
jf(l10) NEXT:[read (Unit), r(11)] PREV:[r(a)]
r(11) NEXT:[jmp(l11)] PREV:[jf(l10)]
jmp(l11) NEXT:[r(12)] PREV:[r(11)]
r(10) NEXT:[r(a)] PREV:[jmp(l9), r(9)]
r(a) NEXT:[jf(l10)] PREV:[r(10)]
jf(l10) NEXT:[read (Unit), r(11)] PREV:[r(a)]
r(11) NEXT:[jmp(l11)] PREV:[jf(l10)]
jmp(l11) NEXT:[r(12)] PREV:[r(11)]
l10:
read (Unit) NEXT:[r(12)] PREV:[jf(l10)]
read (Unit) NEXT:[r(12)] PREV:[jf(l10)]
l11:
r(12) NEXT:[r(a)] PREV:[jmp(l11), read (Unit)]
r(a) NEXT:[jf(l12)] PREV:[r(12)]
jf(l12) NEXT:[r(13), read (Unit)] PREV:[r(a)]
read (Unit) NEXT:[jmp(l13)] PREV:[jf(l12)]
jmp(l13) NEXT:[r(14)] PREV:[read (Unit)]
r(12) NEXT:[r(a)] PREV:[jmp(l11), read (Unit)]
r(a) NEXT:[jf(l12)] PREV:[r(12)]
jf(l12) NEXT:[r(13), read (Unit)] PREV:[r(a)]
read (Unit) NEXT:[jmp(l13)] PREV:[jf(l12)]
jmp(l13) NEXT:[r(14)] PREV:[read (Unit)]
l12:
r(13) NEXT:[r(14)] PREV:[jf(l12)]
r(13) NEXT:[r(14)] PREV:[jf(l12)]
l13:
r(14) NEXT:[<END>] PREV:[jmp(l13), r(13)]
r(14) NEXT:[<END>] PREV:[jmp(l13), r(13)]
l1:
<END> NEXT:[<SINK>] PREV:[r(14)]
<END> NEXT:[<SINK>] PREV:[r(14)]
error:
<ERROR> NEXT:[] PREV:[]
<ERROR> NEXT:[] PREV:[]
sink:
<SINK> NEXT:[] PREV:[<END>]
<SINK> NEXT:[] PREV:[<END>]
=====================
compiler/testData/cfg/LocalDeclarations.instructions
+4 -2
View File
@@ -80,8 +80,10 @@ sink:
fun doSmth(i: Int) {}
---------------------
l0:
<START> NEXT:[read (Unit)] PREV:[]
read (Unit) NEXT:[<END>] PREV:[<START>]
<START> NEXT:[v(i: Int)] PREV:[]
v(i: Int) NEXT:[w(i)] PREV:[<START>]
w(i) NEXT:[read (Unit)] PREV:[v(i: Int)]
read (Unit) NEXT:[<END>] PREV:[w(i)]
l1:
<END> NEXT:[<SINK>] PREV:[read (Unit)]
error:
compiler/testData/checkerWithErrorTypes/quick/Abstract.jet
+2 -2
View File
@@ -237,7 +237,7 @@ abstract class B3(i: Int) {
this(): this(1)
}
fun foo(c: B3) {
fun foo(<!UNUSED_PARAMETER!>c<!>: B3) {
val <!UNUSED_VARIABLE!>a<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B3()<!>
val <!UNUSED_VARIABLE!>b<!> = <!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B1(2, "s")<!>
}
}
compiler/testData/checkerWithErrorTypes/quick/AutoCreatedIt.jet
+6 -6
View File
@@ -15,18 +15,18 @@ fun text() {
bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> => it}<!>
}
fun bar(f : fun (Int, Int) : Int) {}
fun bar1(f : fun (Int) : Int) {}
fun bar2(f : fun () : Int) {}
fun bar(<!UNUSED_PARAMETER!>f<!> : fun (Int, Int) : Int) {}
fun bar1(<!UNUSED_PARAMETER!>f<!> : fun (Int) : Int) {}
fun bar2(<!UNUSED_PARAMETER!>f<!> : fun () : Int) {}
fun String.to(dest : String) {
fun String.to(<!UNUSED_PARAMETER!>dest<!> : String) {
}
fun String.on(predicate : fun (s : URI) : Boolean) : URI {
fun String.on(<!UNUSED_PARAMETER!>predicate<!> : fun (s : URI) : Boolean) : URI {
return URI(this)
}
class URI(val body : Any) {
fun to(dest : String) {}
fun to(<!UNUSED_PARAMETER!>dest<!> : String) {}
}
compiler/testData/checkerWithErrorTypes/quick/AutocastsForStableIdentifiers.jet
+2 -2
View File
@@ -16,7 +16,7 @@ class AClass() {
val x : Any? = 1
fun Any?.vars(a: Any?) : Int {
fun Any?.vars(<!UNUSED_PARAMETER!>a<!>: Any?) : Int {
var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>b<!>: Int = 0
if (ns.y is Int) {
b = <!UNUSED_VALUE!>ns.y<!>
@@ -88,4 +88,4 @@ open class C {
t = <!UNUSED_VALUE!>this@C<!>
}
}
}
}
compiler/testData/checkerWithErrorTypes/quick/Basic.jet
+1 -1
View File
@@ -1,4 +1,4 @@
fun foo(u : Unit) : Int = 1
fun foo(<!UNUSED_PARAMETER!>u<!> : Unit) : Int = 1
fun test() : Int {
foo(<!TYPE_MISMATCH!>1<!>)
compiler/testData/checkerWithErrorTypes/quick/BinaryCallsOnNullableValues.jet
+3 -3
View File
@@ -1,13 +1,13 @@
class A() {
fun equals(a : Any?) : Boolean = false
fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean = false
}
class B() {
fun equals(a : Any?) : Boolean? = false
fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean? = false
}
class C() {
fun equals(a : Any?) : Int = 0
fun equals(<!UNUSED_PARAMETER!>a<!> : Any?) : Int = 0
}
fun f(): Unit {
compiler/testData/checkerWithErrorTypes/quick/BreakContinue.jet
+2 -2
View File
@@ -1,6 +1,6 @@
class C {
fun f (a : Boolean, b : Boolean) {
fun f (<!UNUSED_PARAMETER!>a<!> : Boolean, <!UNUSED_PARAMETER!>b<!> : Boolean) {
@b (while (true)
@a {
<!NOT_A_LOOP_LABEL!>break@f<!>
@@ -25,7 +25,7 @@ class C {
<!NOT_A_LOOP_LABEL!>break@f<!>
}
fun containsBreak(a: String?, b: String?) {
fun containsBreak(a: String?, <!UNUSED_PARAMETER!>b<!>: String?) {
while (a == null) {
break;
}
compiler/testData/checkerWithErrorTypes/quick/ConflictingOverloads.jet
+9 -10
View File
@@ -1,9 +1,9 @@
// http://youtrack.jetbrains.net/issue/KT-424
class A {
<!CONFLICTING_OVERLOADS!>fun a(a: Int): Int<!> = 0
<!CONFLICTING_OVERLOADS!>fun a(<!UNUSED_PARAMETER!>a<!>: Int): Int<!> = 0
<!CONFLICTING_OVERLOADS!>fun a(a: Int)<!> {
<!CONFLICTING_OVERLOADS!>fun a(<!UNUSED_PARAMETER!>a<!>: Int)<!> {
}
<!CONFLICTING_OVERLOADS!>fun b()<!> {
@@ -14,17 +14,17 @@ class A {
}
namespace deepSpace {
<!CONFLICTING_OVERLOADS!>fun c(s: String)<!> {
<!CONFLICTING_OVERLOADS!>fun c(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
<!CONFLICTING_OVERLOADS!>fun c(s: String)<!> {
<!CONFLICTING_OVERLOADS!>fun c(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
class B {
<!CONFLICTING_OVERLOADS!>fun d(s: String)<!> {
<!CONFLICTING_OVERLOADS!>fun d(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
<!CONFLICTING_OVERLOADS!>fun d(s: String)<!> {
<!CONFLICTING_OVERLOADS!>fun d(<!UNUSED_PARAMETER!>s<!>: String)<!> {
}
}
}
@@ -49,9 +49,9 @@ namespace ns3 {
// check same rules apply for ext functions
namespace extensionFunctions {
<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 1
<!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 1
<!CONFLICTING_OVERLOADS!>fun Int.qwe(a: Float)<!> = 2
<!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 2
fun Int.rty() = 3
@@ -94,5 +94,4 @@ namespace constructorVsFun {
class ololo() { }
}
}
}
}
compiler/testData/checkerWithErrorTypes/quick/DefaultValuesTypechecking.jet
+2 -2
View File
@@ -1,5 +1,5 @@
val x = ""
fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = <!TYPE_MISMATCH!>x<!>, z : String = <!UNRESOLVED_REFERENCE!>y<!>) {
fun bar(<!UNUSED_PARAMETER!>x<!> : Int = <!TYPE_MISMATCH!>""<!>, <!UNUSED_PARAMETER!>y<!> : Int = <!TYPE_MISMATCH!>x<!>, <!UNUSED_PARAMETER!>z<!> : String = <!UNRESOLVED_REFERENCE!>y<!>) {
}
}
compiler/testData/checkerWithErrorTypes/quick/ExtensionFunctions.jet
+9 -9
View File
@@ -3,7 +3,7 @@
fun Int?.optint() : Unit {}
val Int?.optval : Unit = ()
fun <T, E> T.foo(x : E, y : A) : T {
fun <T, E> T.foo(<!UNUSED_PARAMETER!>x<!> : E, y : A) : T {
y.plus(1)
y plus 1
y + 1.0
@@ -15,7 +15,7 @@ fun <T, E> T.foo(x : E, y : A) : T {
class A
fun A.plus(a : Any) {
fun A.plus(<!UNUSED_PARAMETER!>a<!> : Any) {
1.foo()
true.<!NONE_APPLICABLE!>foo<!>()
@@ -23,11 +23,11 @@ fun A.plus(a : Any) {
1
}
fun A.plus(a : Int) {
fun A.plus(<!UNUSED_PARAMETER!>a<!> : Int) {
1
}
fun <T> T.minus(t : T) : Int = 1
fun <T> T.minus(<!UNUSED_PARAMETER!>t<!> : T) : Int = 1
fun test() {
val <!UNUSED_VARIABLE!>y<!> = 1.abs
@@ -41,15 +41,15 @@ fun Int.foo() = this
namespace null_safety {
fun parse(cmd: String): Command? { return null }
fun parse(<!UNUSED_PARAMETER!>cmd<!>: String): Command? { return null }
class Command() {
// fun equals(other : Any?) : Boolean
val foo : Int = 0
}
fun Any.equals(other : Any?) : Boolean = true
fun Any?.equals1(other : Any?) : Boolean = true
fun Any.equals2(other : Any?) : Boolean = true
fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun Any?.equals1(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun Any.equals2(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun main(args: Array<String>) {
@@ -70,4 +70,4 @@ namespace null_safety {
if (command == null) 1
}
}
}
compiler/testData/checkerWithErrorTypes/quick/FunctionCalleeExpressions.jet
+1 -1
View File
@@ -51,7 +51,7 @@ fun main(args : Array<String>) {
fun f() : fun Int.() : Unit = {}
fun main1(args : Array<String>) {
fun main1() {
1.{Int.() => 1}();
{1}()
{(x : Int) => x}(1)
compiler/testData/checkerWithErrorTypes/quick/GenericFunctionIsLessSpecific.jet
+2 -2
View File
@@ -1,6 +1,6 @@
// A generic funciton is always less specific than a non-generic one
fun foo<T>(t : T) : Unit {}
fun foo(i : Int) : Int = 1
fun foo<T>(<!UNUSED_PARAMETER!>t<!> : T) : Unit {}
fun foo(<!UNUSED_PARAMETER!>i<!> : Int) : Int = 1
fun test() {
foo(1) : Int
compiler/testData/checkerWithErrorTypes/quick/InferNullabilityInThenBlock.jet
+2 -4
View File
@@ -1,5 +1,4 @@
fun ff(a: String) = 1
fun ff(<!UNUSED_PARAMETER!>a<!>: String) = 1
fun gg() {
val a: String? = ""
@@ -7,5 +6,4 @@ fun gg() {
if (a != null) {
ff(a)
}
}
}
compiler/testData/checkerWithErrorTypes/quick/LValueAssignment.jet
+9 -9
View File
@@ -7,7 +7,7 @@ open class B() {
class C() : B() {
var x = 4
fun foo(c: C) {
fun foo(<!UNUSED_PARAMETER!>c<!>: C) {
this.x = 34
this.b = 123
super.b = 23
@@ -17,7 +17,7 @@ class C() : B() {
<!VARIABLE_EXPECTED!>getInt()<!> = 12
}
fun foo1(c: C) {
fun foo1(<!UNUSED_PARAMETER!>c<!>: C) {
<!VAL_REASSIGNMENT!>super.c<!> = 34
}
@@ -36,7 +36,7 @@ class D() {
}
}
fun cannotBe(var i: Int) {
fun cannotBe(var <!UNUSED_PARAMETER!>i<!>: Int) {
<!UNRESOLVED_REFERENCE!>z<!> = 30;
<!VARIABLE_EXPECTED!>()<!> = ();
@@ -47,18 +47,18 @@ fun cannotBe(var i: Int) {
}
fun canBe(var i: Int, val j: Int) {
(i: Int) = 36
(@label i) = 34
(i: Int) = <!UNUSED_VALUE!>36<!>
(@label i) = <!UNUSED_VALUE!>34<!>
(<!VAL_REASSIGNMENT!>j<!>: Int) = 36
(@label j) = 34 //repeat for j
(<!VAL_REASSIGNMENT!>j<!>: Int) = <!UNUSED_VALUE!>36<!>
(@label j) = <!UNUSED_VALUE!>34<!> //repeat for j
val a = A()
(@ a.a) = 3894
}
fun canBe2(val j: Int) {
(@label <!VAL_REASSIGNMENT!>j<!>) = 34
(@label <!VAL_REASSIGNMENT!>j<!>) = <!UNUSED_VALUE!>34<!>
}
class A() {
@@ -140,4 +140,4 @@ fun Array<Int>.checkThis() {
abstract class Ab {
abstract fun getArray() : Array<Int>
}
}
compiler/testData/checkerWithErrorTypes/quick/NamedArgumentsAndDefaultValues.jet
+2 -2
View File
@@ -1,7 +1,7 @@
fun foo(a : Int = 1, b : String = "abc") {
fun foo(<!UNUSED_PARAMETER!>a<!> : Int = 1, <!UNUSED_PARAMETER!>b<!> : String = "abc") {
}
fun bar(x : Int = 1, y : Int = 1, z : String) {
fun bar(<!UNUSED_PARAMETER!>x<!> : Int = 1, <!UNUSED_PARAMETER!>y<!> : Int = 1, <!UNUSED_PARAMETER!>z<!> : String) {
}
fun test() {
compiler/testData/checkerWithErrorTypes/quick/ResolveOfJavaGenerics.jet
+5 -5
View File
@@ -1,7 +1,7 @@
// +JDK
// Fixpoint generic in Java: Enum<T extends Enum<T>>
fun test(a : annotation.RetentionPolicy) {
fun test(<!UNUSED_PARAMETER!>a<!> : annotation.RetentionPolicy) {
}
@@ -9,14 +9,14 @@ fun test() {
java.util.Collections.emptyList()
}
fun test(a : java.lang.Comparable<Int>) {
fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.Comparable<Int>) {
}
fun test(a : java.util.ArrayList<Int>) {
fun test(<!UNUSED_PARAMETER!>a<!> : java.util.ArrayList<Int>) {
}
fun test(a : java.lang.Class<Int>) {
fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.Class<Int>) {
}
}
compiler/testData/checkerWithErrorTypes/quick/ResolveToJava.jet
+2 -2
View File
@@ -9,7 +9,7 @@ import java.lang.Comparable as Com
val l : List<in Int> = ArrayList<Int>()
fun test(l : java.util.List<Int>) {
fun test(<!UNUSED_PARAMETER!>l<!> : java.util.List<Int>) {
val <!UNUSED_VARIABLE!>x<!> : java.<!UNRESOLVED_REFERENCE!>List<!>
val <!UNUSED_VARIABLE!>y<!> : java.util.List<Int>
val <!UNUSED_VARIABLE!>b<!> : java.lang.Object
@@ -51,4 +51,4 @@ fun test(l : java.util.List<Int>) {
namespace xxx {
import java.lang.Class;
}
}
compiler/testData/checkerWithErrorTypes/quick/Super.jet
+1 -1
View File
@@ -1,6 +1,6 @@
namespace example;
fun any(a : Any) {}
fun any(<!UNUSED_PARAMETER!>a<!> : Any) {}
fun notAnExpression() {
any(<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>) // not an expression
compiler/testData/checkerWithErrorTypes/quick/TypeInference.jet
+1 -1
View File
@@ -2,7 +2,7 @@ class C<T>() {
fun foo() : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
}
fun foo(c: C<Int>) {}
fun foo(<!UNUSED_PARAMETER!>c<!>: C<Int>) {}
fun bar<T>() : C<T> <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
fun main(args : Array<String>) {
compiler/testData/checkerWithErrorTypes/quick/UninitializedOrReassignedVariables.jet
+6 -6
View File
@@ -1,7 +1,7 @@
namespace uninitialized_reassigned_variables
fun doSmth(s: String) {}
fun doSmth(i: Int) {}
fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
// ------------------------------------------------
// uninitialized variables
@@ -54,9 +54,9 @@ fun t2() {
class A() {}
fun t4(a: A, val b: A, var c: A) {
<!VAL_REASSIGNMENT!>a<!> = A()
<!VAL_REASSIGNMENT!>b<!> = A()
c = A()
<!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>A()<!>
<!VAL_REASSIGNMENT!>b<!> = <!UNUSED_VALUE!>A()<!>
c = <!UNUSED_VALUE!>A()<!>
}
// ------------------------------------------------
@@ -191,7 +191,7 @@ class AnonymousInitializers(var a: String, val b: String) {
}
fun reassignFunParams(val a: Int) {
<!VAL_REASSIGNMENT!>a<!> = 1
<!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>1<!>
}
open class Open(a: Int, w: Int) {}
compiler/testData/checkerWithErrorTypes/quick/UnreachableCode.jet
+4 -4
View File
@@ -47,7 +47,7 @@ fun t3() : Any {
<!UNREACHABLE_CODE!>1<!>
}
fun t4(a : Boolean) : Int {
fun t4(<!UNUSED_PARAMETER!>a<!> : Boolean) : Int {
do {
return 1
}
@@ -55,7 +55,7 @@ fun t4(a : Boolean) : Int {
<!UNREACHABLE_CODE!>1<!>
}
fun t4break(a : Boolean) : Int {
fun t4break(<!UNUSED_PARAMETER!>a<!> : Boolean) : Int {
do {
break
}
@@ -162,7 +162,7 @@ fun nullIsNotNothing() : Unit {
fail()
}
fun returnInWhile(a: Int) {
fun returnInWhile(<!UNUSED_PARAMETER!>a<!>: Int) {
do {return}
while (<!UNREACHABLE_CODE!>1 > a<!>)
}
}
compiler/testData/checkerWithErrorTypes/quick/Unresolved.jet
+1 -1
View File
@@ -28,4 +28,4 @@ fun testUnresolved() {
}
}
fun foo1(i: Int) {}
fun foo1(<!UNUSED_PARAMETER!>i<!>: Int) {}
compiler/testData/checkerWithErrorTypes/quick/UnusedVariables.jet
+3 -3
View File
@@ -86,8 +86,8 @@ class MyTest() {
}
}
fun doSmth(s: String) {}
fun doSmth(a: Any) {}
fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
fun doSmth(<!UNUSED_PARAMETER!>a<!>: Any) {}
}
fun testInnerFunctions() {
@@ -139,4 +139,4 @@ fun testBackingFieldsNotMarked() {
}
}
fun doSmth(i : Int) {}
fun doSmth(<!UNUSED_PARAMETER!>i<!> : Int) {}
compiler/testData/checkerWithErrorTypes/quick/Varargs.jet
+3 -3
View File
@@ -1,5 +1,5 @@
fun v(x : Int, y : String, vararg f : Long) {}
fun v1(vararg f : fun (Int) : Unit) {}
fun v(<!UNUSED_PARAMETER!>x<!> : Int, <!UNUSED_PARAMETER!>y<!> : String, vararg <!UNUSED_PARAMETER!>f<!> : Long) {}
fun v1(vararg <!UNUSED_PARAMETER!>f<!> : fun (Int) : Unit) {}
fun test() {
v(1, "")
@@ -14,4 +14,4 @@ fun test() {
v1({}, {}, {it})
v1({}) <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
v1 <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
}
}
compiler/testData/checkerWithErrorTypes/quick/Variance.jet
+6 -6
View File
@@ -19,17 +19,17 @@ fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
//Arrays copy example
class Array<T>(val length : Int, val t : T) {
fun get(index : Int) : T { return t }
fun set(index : Int, value : T) { /* ... */ }
fun get(<!UNUSED_PARAMETER!>index<!> : Int) : T { return t }
fun set(<!UNUSED_PARAMETER!>index<!> : Int, <!UNUSED_PARAMETER!>value<!> : T) { /* ... */ }
}
fun copy1(from : Array<Any>, to : Array<Any>) {}
fun copy1(<!UNUSED_PARAMETER!>from<!> : Array<Any>, <!UNUSED_PARAMETER!>to<!> : Array<Any>) {}
fun copy2(from : Array<out Any>, to : Array<in Any>) {}
fun copy2(<!UNUSED_PARAMETER!>from<!> : Array<out Any>, <!UNUSED_PARAMETER!>to<!> : Array<in Any>) {}
fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
fun <T> copy3(<!UNUSED_PARAMETER!>from<!> : Array<out T>, <!UNUSED_PARAMETER!>to<!> : Array<in T>) {}
fun copy4(from : Array<out Number>, to : Array<in Int>) {}
fun copy4(<!UNUSED_PARAMETER!>from<!> : Array<out Number>, <!UNUSED_PARAMETER!>to<!> : Array<in Int>) {}
fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
copy1(<!TYPE_MISMATCH!>ints<!>, any)
compiler/testData/checkerWithErrorTypes/quick/nullabilityAndAutoCasts/InfixCallNullability.jet
+5 -5
View File
@@ -1,11 +1,11 @@
class A() {
fun plus(i : Int) {}
fun plus(<!UNUSED_PARAMETER!>i<!> : Int) {}
fun minus() {}
fun contains(a : Any?) : Boolean = true
fun contains(<!UNUSED_PARAMETER!>a<!> : Any?) : Boolean = true
}
fun A.div(i : Int) {}
fun A?.times(i : Int) {}
fun A.div(<!UNUSED_PARAMETER!>i<!> : Int) {}
fun A?.times(<!UNUSED_PARAMETER!>i<!> : Int) {}
fun test(x : Int?, a : A?) {
x<!UNSAFE_CALL!>.<!>plus(1)
@@ -38,4 +38,4 @@ fun test(x : Int?, a : A?) {
a <!UNSAFE_INFIX_CALL!>contains<!> 1
a<!UNSAFE_CALL!>.<!>contains(1)
a?.contains(1)
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/AmbiguityOnLazyTypeComputation.jet
+3 -3
View File
@@ -7,6 +7,6 @@ val b : Foo = Foo()
val a1 = b.compareTo(2)
class Foo() {
fun compareTo(other : Byte) : Int = 0
fun compareTo(other : Char) : Int = 0
}
fun compareTo(<!UNUSED_PARAMETER!>other<!> : Byte) : Int = 0
fun compareTo(<!UNUSED_PARAMETER!>other<!> : Char) : Int = 0
}
compiler/testData/checkerWithErrorTypes/quick/regressions/CoercionToUnit.jet
+1 -1
View File
@@ -1,4 +1,4 @@
fun foo(u : Unit) : Int = 1
fun foo(<!UNUSED_PARAMETER!>u<!> : Unit) : Int = 1
fun test() : Int {
foo(<!TYPE_MISMATCH!>1<!>)
compiler/testData/checkerWithErrorTypes/quick/regressions/ErrorsOnIbjectExpressionsAsParameters.jet
+1 -1
View File
@@ -1,4 +1,4 @@
fun foo(a : Any) {}
fun foo(<!UNUSED_PARAMETER!>a<!> : Any) {}
fun test() {
foo(object {});
compiler/testData/checkerWithErrorTypes/quick/regressions/Jet124.jet
+2 -2
View File
@@ -1,8 +1,8 @@
fun foo1() : fun (Int) : Int = { (x: Int) => x }
fun foo() {
val <!UNUSED_VARIABLE!>h<!> : fun (Int) : Int = foo1();
val h : fun (Int) : Int = foo1();
h(1)
val <!UNUSED_VARIABLE!>m<!> : fun (Int) : Int = {(a : Int) => 1}//foo1()
val m : fun (Int) : Int = {(a : Int) => 1}//foo1()
m(1)
}
compiler/testData/checkerWithErrorTypes/quick/regressions/Jet169.jet
+2 -2
View File
@@ -1,8 +1,8 @@
fun set(key : String, value : String) {
fun set(<!UNUSED_PARAMETER!>key<!> : String, <!UNUSED_PARAMETER!>value<!> : String) {
val a : String? = ""
when (a) {
"" => a<!UNSAFE_CALL!>.<!>get(0)
is String, is Any => a.compareTo("")
else => a.toString()
}
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/Jet69.jet
+2 -2
View File
@@ -1,10 +1,10 @@
class Command() {}
fun parse(cmd: String): Command? { return null }
fun parse(<!UNUSED_PARAMETER!>cmd<!>: String): Command? { return null }
fun Any.equals(other : Any?) : Boolean = this === other
fun main(args: Array<String>) {
val command = parse("")
if (command == null) 1 // error on this line, but must be OK
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/OutProjections.jet
+2 -2
View File
@@ -3,7 +3,7 @@ class Point() {
class G<T>() {}
fun f<T>(expression : T) : G<out T> = G<T>
fun f<T>(<!UNUSED_PARAMETER!>expression<!> : T) : G<out T> = G<T>
fun foo() : G<Point> {
@@ -13,7 +13,7 @@ fun foo() : G<Point> {
class Out<out T>() {}
fun fout<T>(expression : T) : Out<out T> = Out<T>
fun fout<T>(<!UNUSED_PARAMETER!>expression<!> : T) : Out<out T> = Out<T>
fun fooout() : Out<Point> {
val p = Point();
compiler/testData/checkerWithErrorTypes/quick/regressions/ScopeForSecondaryConstructors.jet
+1 -1
View File
@@ -8,7 +8,7 @@ class Foo(var bar : Int, var barr : Int, var barrr : Int) {
}
this(var bar : Int) : this(1, 1, 1) {
bar = 1
bar = <!UNUSED_VALUE!>1<!>
this.bar
1 : Int
val <!UNUSED_VARIABLE!>a<!> : Int =1
compiler/testData/checkerWithErrorTypes/quick/regressions/SpecififcityByReceiver.jet
+1 -1
View File
@@ -1,4 +1,4 @@
fun Any.equals(other : Any?) : Boolean = true
fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun main(args: Array<String>) {
compiler/testData/checkerWithErrorTypes/quick/regressions/WrongTraceInCallResolver.jet
+2 -2
View File
@@ -1,8 +1,8 @@
open class Foo {}
open class Bar {}
fun <T : Bar, T1> foo(x : Int) {}
fun <T1, T : Foo> foo(x : Long) {}
fun <T : Bar, T1> foo(<!UNUSED_PARAMETER!>x<!> : Int) {}
fun <T1, T : Foo> foo(<!UNUSED_PARAMETER!>x<!> : Long) {}
fun f(): Unit {
foo<<!UPPER_BOUND_VIOLATED!>Int<!>, Int>(1)
compiler/testData/checkerWithErrorTypes/quick/regressions/kt510.jet → compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt510.jet
View File
compiler/testData/checkerWithErrorTypes/quick/regressions/kt607.jet → compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt607.jet
View File
compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt609.jet
+19
View File
@@ -0,0 +1,19 @@
//KT-609 Analyze not only local variables, but function parameters as well in 'unused values' analysis
namespace kt609
fun test(var a: Int) {
a = <!UNUSED_VALUE!>324<!> //should be an 'unused value' warning here
}
class C() {
fun foo(<!UNUSED_PARAMETER!>s<!>: String) {} //should be an 'unused variable' warning
}
open class A() {
open fun foo(s : String) {} //should not be a warning
}
class B() : A() {
final override fun foo(s : String) {} //should not be a warning
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt610.jet → compiler/testData/checkerWithErrorTypes/quick/regressions/control-flow-analysis/kt610.jet
View File
compiler/testData/checkerWithErrorTypes/quick/regressions/kt127.jet
+3 -3
View File
@@ -2,8 +2,8 @@
class Foo() {}
fun Any.equals(other : Any?) : Boolean = true
fun Any?.equals1(other : Any?) : Boolean = true
fun Any.equals(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun Any?.equals1(<!UNUSED_PARAMETER!>other<!> : Any?) : Boolean = true
fun main(args: Array<String>) {
@@ -15,4 +15,4 @@ fun main(args: Array<String>) {
// ?.equals(null) => 1 // same here
// }
command.equals(null)
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt128.jet
+1 -1
View File
@@ -1,6 +1,6 @@
// KT-128 Support passing only the last closure if all the other parameters have default values
fun div(c : String = "", f : fun()) {}
fun div(<!UNUSED_PARAMETER!>c<!> : String = "", <!UNUSED_PARAMETER!>f<!> : fun()) {}
fun f() {
div { // Nothing passed, but could have been...
// ...
compiler/testData/checkerWithErrorTypes/quick/regressions/kt174.jet
+8
View File
@@ -0,0 +1,8 @@
// KT-174 Nullability info for extension function receivers
// +JDK
trait Tree {}
fun Any?.TreeValue() : Tree {
if (this is Tree) return this
throw Exception()
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt201.jet
+9
View File
@@ -0,0 +1,9 @@
// KT-201 Allow to call extension with nullable receiver with a '.'
// +JDK
fun <T : Any> T?.npe() : T = if (this == null) throw NullPointerException() else this
fun foo() {
val i : Int? = 1
i.npe() // error!
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt235.jet
+5 -5
View File
@@ -36,15 +36,15 @@ fun main(args: Array<String>) {
}
class MyArray() {
fun get(i: Int): Int = 1
fun set(i: Int, value: Int): Int = 1
fun get(<!UNUSED_PARAMETER!>i<!>: Int): Int = 1
fun set(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>value<!>: Int): Int = 1
}
class MyArray1() {
fun get(i: Int): Int = 1
fun set(i: Int, value: Int) {}
fun get(<!UNUSED_PARAMETER!>i<!>: Int): Int = 1
fun set(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>value<!>: Int) {}
}
class MyNumber() {
fun inc(): MyNumber = MyNumber()
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt258.jet
+1 -1
View File
@@ -8,4 +8,4 @@ fun test() {
attributes["href"] = "1" // inference fails, but it shouldn't
}
fun <K, V> java.util.Map<K, V>.set(key : K, value : V) {}//= this.put(key, value)
fun <K, V> java.util.Map<K, V>.set(<!UNUSED_PARAMETER!>key<!> : K, <!UNUSED_PARAMETER!>value<!> : V) {}//= this.put(key, value)
compiler/testData/checkerWithErrorTypes/quick/regressions/kt282.jet
+3 -3
View File
@@ -1,12 +1,12 @@
// KT-282 Nullability in extension functions and in binary calls
class Set {
fun contains(x : Int) : Boolean = true
fun contains(<!UNUSED_PARAMETER!>x<!> : Int) : Boolean = true
}
fun Set?.plus(x : Int) : Int = 1
fun Set?.plus(<!UNUSED_PARAMETER!>x<!> : Int) : Int = 1
fun Int?.contains(x : Int) : Boolean = false
fun Int?.contains(<!UNUSED_PARAMETER!>x<!> : Int) : Boolean = false
fun f(): Unit {
var set : Set? = null
compiler/testData/checkerWithErrorTypes/quick/regressions/kt287.jet
+2 -2
View File
@@ -6,8 +6,8 @@ import java.util.*
fun attributes() : Map<String, String> = HashMap() // Should be inferred;
val attributes : Map<String, String> = HashMap() // Should be inferred;
fun foo(m : Map<String, String>) {}
fun foo(<!UNUSED_PARAMETER!>m<!> : Map<String, String>) {}
fun test() {
foo(HashMap())
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt312.jet
+10
View File
@@ -0,0 +1,10 @@
// KT-312 Nullability problem when a nullable version of a generic type is returned
fun <T> Array<out T>.safeGet(index : Int) : T? {
return if (index < size) this[index] else null
}
val args : Array<String> = Array<String>(1)
val name : String = <!TYPE_MISMATCH!>args.safeGet<String>(0)<!> // No error, must be type mismatch
val name1 : String? = args.safeGet(0)
compiler/testData/checkerWithErrorTypes/quick/regressions/kt335.336.jet
+2 -2
View File
@@ -9,7 +9,7 @@ fun <T : java.lang.Comparable<T>> List<T>.sort() {
Collections.sort(this) // Error here
}
fun <T> List<T>.plus(other : List<T>) : List<T> {
fun <T> List<T>.plus(<!UNUSED_PARAMETER!>other<!> : List<T>) : List<T> {
val result = ArrayList(this)
return result
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt352.jet
+1 -1
View File
@@ -18,7 +18,7 @@ val g : fun() : Unit = <!TYPE_MISMATCH!>{ (): Int => 42 }<!>
val h : fun() : Unit = { doSmth() }
fun doSmth(): Int = 42
fun doSmth(a: String) {}
fun doSmth(<!UNUSED_PARAMETER!>a<!>: String) {}
val testIt : fun(Any) : Unit = {
if (it is String) {
compiler/testData/checkerWithErrorTypes/quick/regressions/kt398.jet
+11
View File
@@ -0,0 +1,11 @@
// KT-398 Internal error when property initializes with function
class X<T>() {
val check = { (a : Any) => a is T }
}
fun box() : String {
if(X<String>().check(10)) return "fail"
if(!X<String>().check("lala")) return "fail"
return "OK"
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt399.jet
+1 -1
View File
@@ -1,6 +1,6 @@
// KT-399 Type argument inference not implemented for CALL_EXPRESSION
fun <T> getSameTypeChecker(obj: T) : Function1<Any,Boolean> {
fun <T> getSameTypeChecker(<!UNUSED_PARAMETER!>obj<!>: T) : Function1<Any,Boolean> {
return { (a : Any) => a is T }
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt411.jet
+1 -1
View File
@@ -9,7 +9,7 @@ fun f() {
}
)
}
fun invoker(gen : fun() : Int) : Int = 0
fun invoker(<!UNUSED_PARAMETER!>gen<!> : fun() : Int) : Int = 0
//more tests
fun t1() {
compiler/testData/checkerWithErrorTypes/quick/regressions/kt439.jet
+2 -2
View File
@@ -2,6 +2,6 @@
inline fun run1<T>(body : fun() : T) : T = body()
fun main1(args : Array<String>) {
fun main1(<!UNUSED_PARAMETER!>args<!> : Array<String>) {
run1 @l{ 1 } // should not be an error
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt442.jet
+1 -1
View File
@@ -6,7 +6,7 @@ fun testFunny() {
val <!UNUSED_VARIABLE!>a<!> : Int = funny {1}
}
fun <T> funny2(f : fun(t : T) : T) : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
fun <T> funny2(<!UNUSED_PARAMETER!>f<!> : fun(t : T) : T) : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
fun testFunny2() {
val <!UNUSED_VARIABLE!>a<!> : Int = funny2 {it}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt455.jet
+1 -1
View File
@@ -7,4 +7,4 @@ fun foo() {
doSmth(<!UNINITIALIZED_VARIABLE!>a<!>) //error
doSmth(a) //no repeat error
}
fun doSmth(i: Int) {}
fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt459.jet
+1 -1
View File
@@ -6,4 +6,4 @@ fun test() {
attributes["href"] = "1" // inference fails, but it shouldn't
}
fun <K, V> java.util.Map<K, V>.set(key : K, value : V) {}//= this.put(key, value)
fun <K, V> java.util.Map<K, V>.set(<!UNUSED_PARAMETER!>key<!> : K, <!UNUSED_PARAMETER!>value<!> : V) {}//= this.put(key, value)
compiler/testData/checkerWithErrorTypes/quick/regressions/kt524.jet
+17
View File
@@ -0,0 +1,17 @@
// KT-524 sure() returns T
// +JDK
namespace StringBuilder
import java.lang.StringBuilder
//import std.io.*
//import java.io.*
fun main(args : Array<String>) {
}
val Int.bd : StringBuilder get() = StringBuilder(this.toString())
fun StringBuilder.plus(other : StringBuilder) : StringBuilder = this.append(other).sure1() // !!!
fun <T : Any> T?.sure1() : T { return if (this != null) this else throw NullPointerException() }
compiler/testData/checkerWithErrorTypes/quick/regressions/kt58.jet
+2 -2
View File
@@ -88,5 +88,5 @@ fun t7() : Int {
}
}
fun doSmth(i: Int) {
}
fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt597.jet
+20
View File
@@ -0,0 +1,20 @@
//KT-597 Type inference failed
// +JDK
fun <T> Array<T>?.get(i: Int) : T {
if (this != null)
return this.get(i) // <- inferred type is Any? but &T was excepted
else throw NullPointerException()
}
fun Int?.inc() : Int {
if (this != null)
return this.inc()
else
throw NullPointerException()
}
fun test() {
var i : Int? = 10
var <!UNUSED_VARIABLE!>i_inc<!> = <!UNUSED_CHANGED_VALUE!>i++<!> // <- expected Int?, but returns Any?
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt604.jet
+20
View File
@@ -0,0 +1,20 @@
// KT-604 Internal frontend error
trait ChannelPipeline {
}
class DefaultChannelPipeline() : ChannelPipeline {
}
trait ChannelPipelineFactory{
fun getPipeline() : ChannelPipeline
}
class StandardPipelineFactory(val config: fun ChannelPipeline.():Unit) : ChannelPipelineFactory {
override fun getPipeline() : ChannelPipeline {
val pipeline = DefaultChannelPipeline()
pipeline.config ()
return pipeline
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt618.jet
+6 -6
View File
@@ -1,19 +1,19 @@
namespace lol
class B() {
fun plusAssign(other : B) : String {
fun plusAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
return "s"
}
fun minusAssign(other : B) : String {
fun minusAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
return "s"
}
fun modAssign(other : B) : String {
fun modAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
return "s"
}
fun divAssign(other : B) : String {
fun divAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
return "s"
}
fun timesAssign(other : B) : String {
fun timesAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
return "s"
}
}
@@ -25,4 +25,4 @@ fun main(args : Array<String>) {
<!TYPE_MISMATCH!>c /= B()<!>
<!TYPE_MISMATCH!>c -= B()<!>
<!TYPE_MISMATCH!>c %= B()<!>
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt629.jet
+1 -1
View File
@@ -4,7 +4,7 @@ namespace kt629
class A() {
var p = "yeah"
fun mod(other : A) : A {
fun mod(<!UNUSED_PARAMETER!>other<!> : A) : A {
return A();
}
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt630.jet
+3
View File
@@ -0,0 +1,3 @@
// KT-630 Bad type inference
val x = "lala".sure()
val s : String = x
compiler/testData/checkerWithErrorTypes/quick/regressions/kt688.jet
+14
View File
@@ -0,0 +1,14 @@
// KT-668 Failed to resolve generic parameter
open class A()
open class B() : A() {
fun b(): B = B()
}
class C() {
fun a<T>(x: fun(T):T, y: T): T {
return x(x(y))
}
val x: B = a({it.b()}, B())
}
compiler/testData/checkerWithErrorTypes/quick/regressions/kt691.jet
+2
View File
@@ -0,0 +1,2 @@
// KT-691 Allow to create nested namespaces with dot delimiter
namespace foo.bar.buz
compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInFunctionBody.jet
+2 -3
View File
@@ -1,5 +1,4 @@
fun f(p: Int): Int {
fun f(<!UNUSED_PARAMETER!>p<!>: Int): Int {
val <!NAME_SHADOWING!>p<!> = 2
return p
}
}
compiler/testData/checkerWithErrorTypes/quick/shadowing/ShadowParameterInNestedBlockInFor.jet
+2 -2
View File
@@ -1,7 +1,7 @@
fun f(i: Int) {
fun f(<!UNUSED_PARAMETER!>i<!>: Int) {
for (j in 1..100) {
{
var <!NAME_SHADOWING!>i<!> = 12
}
}
}
}

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