else on the next line
as requested by http://confluence.jetbrains.net/display/JET/Code+Conventions+for+Java (sed is your friend)
This commit is contained in:
@@ -62,7 +62,8 @@ public class DefaultModuleConfiguration implements ModuleConfiguration {
|
||||
if (DescriptorUtils.getFQName(namespaceDescriptor).equals(JetStandardClasses.STANDARD_CLASSES_FQNAME.toUnsafe())) {
|
||||
if (!extendBuiltins) {
|
||||
namespaceMemberScope.importScope(JetStandardClasses.STANDARD_CLASSES);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
namespaceMemberScope.importScope(JetStandardLibrary.getInstance().getLibraryScope());
|
||||
}
|
||||
|
||||
|
||||
@@ -264,13 +264,15 @@ public class JetControlFlowProcessor {
|
||||
else if (left instanceof JetArrayAccessExpression) {
|
||||
JetArrayAccessExpression arrayAccessExpression = (JetArrayAccessExpression) left;
|
||||
visitAssignToArrayAccess(expression, arrayAccessExpression);
|
||||
} else if (left instanceof JetQualifiedExpression) {
|
||||
}
|
||||
else if (left instanceof JetQualifiedExpression) {
|
||||
assert !(left instanceof JetHashQualifiedExpression) : left; // TODO
|
||||
JetQualifiedExpression qualifiedExpression = (JetQualifiedExpression) left;
|
||||
value(qualifiedExpression.getReceiverExpression(), false);
|
||||
value(expression.getOperationReference(), false);
|
||||
builder.write(expression, left);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
builder.unsupported(expression); // TODO
|
||||
}
|
||||
}
|
||||
|
||||
+4
-2
@@ -69,10 +69,12 @@ public class MutableClassDescriptorLite extends MutableDeclarationDescriptor imp
|
||||
private static boolean isStatic(DeclarationDescriptor declarationDescriptor) {
|
||||
if (declarationDescriptor instanceof NamespaceDescriptor) {
|
||||
return true;
|
||||
} else if (declarationDescriptor instanceof ClassDescriptor) {
|
||||
}
|
||||
else if (declarationDescriptor instanceof ClassDescriptor) {
|
||||
ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor;
|
||||
return classDescriptor.getKind() == ClassKind.OBJECT || classDescriptor.getKind() == ClassKind.ENUM_CLASS;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
+2
-1
@@ -80,7 +80,8 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme
|
||||
getAnnotations(),
|
||||
getName(),
|
||||
kind);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return new SimpleFunctionDescriptorImpl(
|
||||
newOwner,
|
||||
// TODO : safeSubstitute
|
||||
|
||||
@@ -483,7 +483,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
if (!at(LBRACE)) {
|
||||
assert _atSet(LABELS);
|
||||
parsePrefixExpression();
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseFunctionLiteral();
|
||||
}
|
||||
success = true;
|
||||
@@ -704,7 +705,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
}
|
||||
else if (at(NULL_KEYWORD)) {
|
||||
parseOneTokenExpression(NULL);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
@@ -735,7 +737,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
myJetParsing.parseModifierList(MODIFIER_LIST, true);
|
||||
myJetParsing.parseProperty(true);
|
||||
property.done(PROPERTY);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseExpression();
|
||||
}
|
||||
|
||||
@@ -780,13 +783,16 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
|
||||
if (atSet(WHEN_CONDITION_RECOVERY_SET)) {
|
||||
error("Expecting an element");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseExpressionPreferringBlocks();
|
||||
}
|
||||
} else if (!atSet(WHEN_CONDITION_RECOVERY_SET)) {
|
||||
}
|
||||
else if (!atSet(WHEN_CONDITION_RECOVERY_SET)) {
|
||||
errorAndAdvance("Expecting '->'");
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseWhenEntryNotElse();
|
||||
}
|
||||
|
||||
@@ -809,7 +815,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
expect(ARROW, "Expecting '->' or 'when'", WHEN_CONDITION_RECOVERY_SET);
|
||||
if (atSet(WHEN_CONDITION_RECOVERY_SET)) {
|
||||
error("Expecting an element");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseExpressionPreferringBlocks();
|
||||
}
|
||||
// SEMI is consumed in parseWhenEntry
|
||||
@@ -833,24 +840,29 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
|
||||
if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) {
|
||||
error("Expecting an element");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseExpression();
|
||||
}
|
||||
condition.done(WHEN_CONDITION_IN_RANGE);
|
||||
} else if (at(IS_KEYWORD) || at(NOT_IS)) {
|
||||
}
|
||||
else if (at(IS_KEYWORD) || at(NOT_IS)) {
|
||||
advance(); // IS_KEYWORD or NOT_IS
|
||||
|
||||
if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) {
|
||||
error("Expecting a type or a decomposer pattern");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parsePattern();
|
||||
}
|
||||
condition.done(WHEN_CONDITION_IS_PATTERN);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
PsiBuilder.Marker expressionPattern = mark();
|
||||
if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) {
|
||||
error("Expecting an expression, is-condition or in-condition");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseExpression();
|
||||
}
|
||||
expressionPattern.done(EXPRESSION_PATTERN);
|
||||
@@ -899,27 +911,33 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
rollbackMarker.rollbackTo();
|
||||
parseBinaryExpression(Precedence.ELVIS);
|
||||
pattern.done(DECOMPOSER_PATTERN);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
rollbackMarker.drop();
|
||||
pattern.done(TYPE_PATTERN);
|
||||
}
|
||||
}
|
||||
} else if (at(HASH)) {
|
||||
}
|
||||
else if (at(HASH)) {
|
||||
parseTuplePattern(TUPLE_PATTERN_ENTRY);
|
||||
pattern.done(TUPLE_PATTERN);
|
||||
}
|
||||
else if (at(MUL)) {
|
||||
advance(); // MUL
|
||||
pattern.done(WILDCARD_PATTERN);
|
||||
} else if (at(VAL_KEYWORD)) {
|
||||
}
|
||||
else if (at(VAL_KEYWORD)) {
|
||||
parseBindingPattern();
|
||||
pattern.done(BINDING_PATTERN);
|
||||
} else if (at(OPEN_QUOTE)) {
|
||||
}
|
||||
else if (at(OPEN_QUOTE)) {
|
||||
parseStringTemplate();
|
||||
pattern.done(EXPRESSION_PATTERN);
|
||||
} else if (parseLiteralConstant()) {
|
||||
}
|
||||
else if (parseLiteralConstant()) {
|
||||
pattern.done(EXPRESSION_PATTERN);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
errorUntil("Pattern expected", TokenSet.create(RBRACE, ARROW));
|
||||
pattern.drop();
|
||||
}
|
||||
@@ -997,14 +1015,16 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
|
||||
parsePattern();
|
||||
subCondition.done(WHEN_CONDITION_IS_PATTERN);
|
||||
} else if (at(IN_KEYWORD) || at(NOT_IN)) {
|
||||
}
|
||||
else if (at(IN_KEYWORD) || at(NOT_IN)) {
|
||||
PsiBuilder.Marker mark = mark();
|
||||
advance(); // IN_KEYWORD ot NOT_IN
|
||||
mark.done(OPERATION_REFERENCE);
|
||||
|
||||
parseExpression();
|
||||
subCondition.done(WHEN_CONDITION_IN_RANGE);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
subCondition.drop();
|
||||
}
|
||||
}
|
||||
@@ -1047,7 +1067,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
PsiBuilder.Marker simpleName = mark();
|
||||
if (at(FIELD_IDENTIFIER)) {
|
||||
advance(); //
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
expect(IDENTIFIER, "Expecting an identifier");
|
||||
}
|
||||
simpleName.done(REFERENCE_EXPRESSION);
|
||||
@@ -1066,7 +1087,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
if (declType != null) {
|
||||
decl.done(declType);
|
||||
return true;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
decl.rollbackTo();
|
||||
return false;
|
||||
}
|
||||
@@ -1343,9 +1365,11 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
}
|
||||
if (at(SEMICOLON)) {
|
||||
while (at(SEMICOLON)) advance(); // SEMICOLON
|
||||
} else if (at(RBRACE)) {
|
||||
}
|
||||
else if (at(RBRACE)) {
|
||||
break;
|
||||
} else if (!myBuilder.newlineBeforeCurrentToken()) {
|
||||
}
|
||||
else if (!myBuilder.newlineBeforeCurrentToken()) {
|
||||
errorUntil("Unexpected tokens (use ';' to separate expressions on the same line)", TokenSet.create(EOL_OR_SEMICOLON));
|
||||
}
|
||||
}
|
||||
@@ -1740,7 +1764,8 @@ public class JetExpressionParsing extends AbstractJetParsing {
|
||||
advance(); // EQ
|
||||
parseExpression();
|
||||
entry.done(LABELED_TUPLE_ENTRY);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseExpression();
|
||||
}
|
||||
|
||||
|
||||
@@ -149,7 +149,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
firstEntry.drop();
|
||||
|
||||
consumeIf(SEMICOLON);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
firstEntry.rollbackTo();
|
||||
}
|
||||
namespaceHeader.done(NAMESPACE_HEADER);
|
||||
@@ -323,7 +324,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
}
|
||||
if (empty) {
|
||||
list.drop();
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
list.done(nodeType);
|
||||
}
|
||||
return !empty;
|
||||
@@ -634,7 +636,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
else if (keywordToken == OBJECT_KEYWORD) {
|
||||
parseObject(true, true);
|
||||
declType = OBJECT_DECLARATION;
|
||||
} else if (keywordToken == LBRACE) {
|
||||
}
|
||||
else if (keywordToken == LBRACE) {
|
||||
parseBlock();
|
||||
declType = ANONYMOUS_INITIALIZER;
|
||||
}
|
||||
@@ -749,7 +752,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
parseTypeRef();
|
||||
reference.done(CONSTRUCTOR_CALLEE);
|
||||
type = DELEGATOR_SUPER_CALL;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
errorWithRecovery("Expecting constructor call (this(...)) or supertype initializer", TokenSet.create(LBRACE, COMMA));
|
||||
initializer.drop();
|
||||
return;
|
||||
@@ -818,7 +822,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
public JetNodeType parseProperty(boolean local) {
|
||||
if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) {
|
||||
advance(); // VAL_KEYWORD or VAR_KEYWORD
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
errorAndAdvance("Expecting 'val' or 'var'");
|
||||
}
|
||||
|
||||
@@ -1034,7 +1039,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
if (!parseIdeTemplate()) {
|
||||
expect(IDENTIFIER, "Expecting " + title + " name or receiver type", nameFollow);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
if (parseIdeTemplate()) {
|
||||
expect(DOT, "Expecting '.' after receiver template");
|
||||
}
|
||||
@@ -1244,7 +1250,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
PsiBuilder.Marker reference = mark();
|
||||
if (expect(IDENTIFIER, "Expecting type parameter name", TokenSet.orSet(TokenSet.create(COLON, COMMA), TYPE_REF_FIRST))) {
|
||||
reference.done(REFERENCE_EXPRESSION);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
reference.drop();
|
||||
}
|
||||
|
||||
@@ -1621,7 +1628,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
parseTypeRef();
|
||||
valueParameter.done(VALUE_PARAMETER);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
parseValueParameter();
|
||||
}
|
||||
if (!at(COMMA)) break;
|
||||
@@ -1708,7 +1716,8 @@ public class JetParsing extends AbstractJetParsing {
|
||||
mark.done(nodeType);
|
||||
}
|
||||
return true;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -38,7 +38,8 @@ public abstract class JetNamedDeclaration extends JetDeclaration implements PsiN
|
||||
if (identifier != null) {
|
||||
String text = identifier.getText();
|
||||
return text != null ? JetPsiUtil.unquoteIdentifier(text) : null;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -268,7 +268,8 @@ public class JetPsiUtil {
|
||||
List<JetDeclaration> declarations = file.getDeclarations();
|
||||
if (declarations.size() == 1) {
|
||||
file.delete();
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
PsiElement parent = clazz.getParent();
|
||||
CodeEditUtil.removeChild(parent.getNode(), clazz.getNode());
|
||||
}
|
||||
|
||||
@@ -52,7 +52,8 @@ public class JetSimpleNameExpression extends JetReferenceExpression {
|
||||
if (!isFirstPartInQualifiedExpression(qualifiedExpression)) {
|
||||
return qualifiedExpression.getReceiverExpression();
|
||||
}
|
||||
} else if (parent instanceof JetCallExpression) {
|
||||
}
|
||||
else if (parent instanceof JetCallExpression) {
|
||||
//This is in case `a().b()`
|
||||
JetCallExpression callExpression = (JetCallExpression) parent;
|
||||
parent = callExpression.getParent();
|
||||
|
||||
@@ -259,7 +259,8 @@ public class DescriptorResolver {
|
||||
if (typeReference == null) {
|
||||
trace.report(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION.on(valueParameter));
|
||||
type = ErrorUtils.createErrorType("Type annotation was missing");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
type = typeResolver.resolveType(parameterScope, typeReference, trace, true);
|
||||
}
|
||||
|
||||
@@ -297,7 +298,8 @@ public class DescriptorResolver {
|
||||
JetType arrayType = JetStandardLibrary.getInstance().getPrimitiveArrayJetTypeByPrimitiveJetType(type);
|
||||
if (arrayType != null) {
|
||||
return arrayType;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return JetStandardLibrary.getInstance().getArrayType(type);
|
||||
}
|
||||
}
|
||||
@@ -472,7 +474,8 @@ public class DescriptorResolver {
|
||||
|| (containingDeclaration instanceof ClassDescriptor);
|
||||
if (isProperty) {
|
||||
return resolveObjectDeclarationAsPropertyDescriptor(containingDeclaration, objectDeclaration, classDescriptor, trace);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return resolveObjectDeclarationAsLocalVariable(containingDeclaration, objectDeclaration, classDescriptor, trace);
|
||||
}
|
||||
}
|
||||
@@ -621,7 +624,8 @@ public class DescriptorResolver {
|
||||
trace.report(PROPERTY_WITH_NO_TYPE_NO_INITIALIZER.on(nameIdentifier));
|
||||
}
|
||||
return ErrorUtils.createErrorType("No type, no body");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
// TODO : a risk of a memory leak
|
||||
LazyValue<JetType> lazyValue = new LazyValueWithDefault<JetType>(ErrorUtils.createErrorType("Recursive dependency")) {
|
||||
@Override
|
||||
@@ -636,7 +640,8 @@ public class DescriptorResolver {
|
||||
return lazyValue.get();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return typeResolver.resolveType(scope, propertyTypeRef, trace, true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -271,9 +271,11 @@ public class DescriptorUtils {
|
||||
if (classifier instanceof ClassDescriptor) {
|
||||
ClassDescriptor clazz = (ClassDescriptor) classifier;
|
||||
return clazz.getKind() == ClassKind.OBJECT || clazz.getKind() == ClassKind.ENUM_ENTRY;
|
||||
} else if (classifier instanceof TypeParameterDescriptor) {
|
||||
}
|
||||
else if (classifier instanceof TypeParameterDescriptor) {
|
||||
return false;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException("unknown classifier: " + classifier);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -75,7 +75,8 @@ public class FqNameUnsafe {
|
||||
if (lastDot >= 0) {
|
||||
shortName = fqName.substring(lastDot + 1);
|
||||
parent = new FqNameUnsafe(fqName.substring(0, lastDot));
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
shortName = fqName;
|
||||
parent = FqName.ROOT.toUnsafe();
|
||||
}
|
||||
@@ -121,7 +122,8 @@ public class FqNameUnsafe {
|
||||
String childFqName;
|
||||
if (isRoot()) {
|
||||
childFqName = name;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
childFqName = fqName + "." + name;
|
||||
}
|
||||
return new FqNameUnsafe(childFqName, this, name);
|
||||
|
||||
@@ -102,10 +102,12 @@ public class OverloadResolver {
|
||||
if (containingDeclaration instanceof NamespaceDescriptor) {
|
||||
NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration;
|
||||
inNamespaces.put(new Key(namespaceDescriptor, klass.getName()), klass.getConstructors());
|
||||
} else if (containingDeclaration instanceof ClassDescriptor) {
|
||||
}
|
||||
else if (containingDeclaration instanceof ClassDescriptor) {
|
||||
ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
|
||||
inClasses.put(classDescriptor, klass.getConstructors());
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -52,11 +52,14 @@ public class OverloadUtil {
|
||||
private static int braceCount(CallableDescriptor a) {
|
||||
if (a instanceof PropertyDescriptor) {
|
||||
return 0;
|
||||
} else if (a instanceof SimpleFunctionDescriptor) {
|
||||
}
|
||||
else if (a instanceof SimpleFunctionDescriptor) {
|
||||
return 1;
|
||||
} else if (a instanceof ConstructorDescriptor) {
|
||||
}
|
||||
else if (a instanceof ConstructorDescriptor) {
|
||||
return 1;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -124,9 +124,11 @@ public class OverrideResolver {
|
||||
public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
|
||||
if (fakeOverride instanceof PropertyDescriptor) {
|
||||
classDescriptor.getScopeForMemberLookupAsWritableScope().addPropertyDescriptor((PropertyDescriptor) fakeOverride);
|
||||
} else if (fakeOverride instanceof SimpleFunctionDescriptor) {
|
||||
}
|
||||
else if (fakeOverride instanceof SimpleFunctionDescriptor) {
|
||||
classDescriptor.getScopeForMemberLookupAsWritableScope().addFunctionDescriptor((SimpleFunctionDescriptor) fakeOverride);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException(fakeOverride.getClass().getName());
|
||||
}
|
||||
}
|
||||
@@ -313,16 +315,19 @@ public class OverrideResolver {
|
||||
if (descriptor.getModality() == Modality.ABSTRACT) {
|
||||
//abstractNoImpl.add(descriptor);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
Collection<CallableMemberDescriptor> overridenDeclarations = OverridingUtil.getOverridenDeclarations(descriptor);
|
||||
if (overridenDeclarations.size() == 0) {
|
||||
throw new IllegalStateException();
|
||||
} else if (overridenDeclarations.size() == 1) {
|
||||
}
|
||||
else if (overridenDeclarations.size() == 1) {
|
||||
CallableMemberDescriptor single = overridenDeclarations.iterator().next();
|
||||
if (single.getModality() == Modality.ABSTRACT) {
|
||||
abstractNoImpl.add(single);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
List<CallableMemberDescriptor> nonAbstractManyImpl = Lists.newArrayList();
|
||||
for (CallableMemberDescriptor overriden : overridenDeclarations) {
|
||||
if (overriden.getModality() != Modality.ABSTRACT) {
|
||||
|
||||
@@ -123,7 +123,8 @@ public class OverridingUtil {
|
||||
private static int compiledValueParameterCount(CallableDescriptor callableDescriptor) {
|
||||
if (callableDescriptor.getReceiverParameter().exists()) {
|
||||
return 1 + callableDescriptor.getValueParameters().size();
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return callableDescriptor.getValueParameters().size();
|
||||
}
|
||||
}
|
||||
@@ -186,7 +187,8 @@ public class OverridingUtil {
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
|
||||
for (int i = 0; i < superValueParameters.size(); ++i) {
|
||||
JetType superValueParameterType = getUpperBound(superValueParameters.get(i));
|
||||
@@ -209,9 +211,11 @@ public class OverridingUtil {
|
||||
private static JetType getUpperBound(JetType type) {
|
||||
if (type.getConstructor().getDeclarationDescriptor() instanceof ClassDescriptor) {
|
||||
return type;
|
||||
} else if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
|
||||
}
|
||||
else if (type.getConstructor().getDeclarationDescriptor() instanceof TypeParameterDescriptor) {
|
||||
return ((TypeParameterDescriptor) type.getConstructor().getDeclarationDescriptor()).getUpperBoundsAsType();
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
throw new IllegalStateException("unknown type constructor: " + type.getConstructor().getClass().getName());
|
||||
}
|
||||
}
|
||||
@@ -253,7 +257,8 @@ public class OverridingUtil {
|
||||
private static void getOverridenDeclarations(CallableMemberDescriptor descriptor, Map<ClassDescriptor, CallableMemberDescriptor> r) {
|
||||
if (descriptor.getKind().isReal()) {
|
||||
r.put((ClassDescriptor) descriptor.getContainingDeclaration(), descriptor);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
if (descriptor.getOverriddenDescriptors().isEmpty()) {
|
||||
throw new IllegalStateException();
|
||||
}
|
||||
|
||||
@@ -102,7 +102,8 @@ public class TypeResolver {
|
||||
JetScope scopeForTypeParameter = getScopeForTypeParameter(typeParameterDescriptor, checkBounds);
|
||||
if (scopeForTypeParameter instanceof ErrorUtils.ErrorScope) {
|
||||
result[0] = ErrorUtils.createErrorType("?");
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
result[0] = new JetTypeImpl(
|
||||
annotations,
|
||||
typeParameterDescriptor.getTypeConstructor(),
|
||||
@@ -130,10 +131,12 @@ public class TypeResolver {
|
||||
if (actualArgumentCount != expectedArgumentCount) {
|
||||
if (actualArgumentCount == 0) {
|
||||
trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type, expectedArgumentCount));
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(type.getTypeArgumentList(), expectedArgumentCount));
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
result[0] = new JetTypeImpl(
|
||||
annotations,
|
||||
typeConstructor,
|
||||
|
||||
+4
-2
@@ -224,7 +224,8 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
|
||||
|
||||
if (allBases.size() == 1) {
|
||||
return allBases.iterator().next();
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
// TODO remove parameter names and parameter default values
|
||||
return descriptor;
|
||||
}
|
||||
@@ -233,7 +234,8 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
|
||||
private static <D extends CallableDescriptor> void getAllDescriptorsForValueArgumentsResolving(D descriptor, Set<D> dest) {
|
||||
if (descriptor.getOverriddenDescriptors().isEmpty()) {
|
||||
dest.add(descriptor);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
for (CallableDescriptor overriden : descriptor.getOverriddenDescriptors()) {
|
||||
getAllDescriptorsForValueArgumentsResolving((D) overriden, dest);
|
||||
}
|
||||
|
||||
@@ -209,7 +209,8 @@ public class CommonSupertypes {
|
||||
if (ins != null) {
|
||||
ins.add(projection.getType());
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
ins = null;
|
||||
}
|
||||
|
||||
@@ -217,7 +218,8 @@ public class CommonSupertypes {
|
||||
if (outs != null) {
|
||||
outs.add(projection.getType());
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
outs = null;
|
||||
}
|
||||
}
|
||||
@@ -232,10 +234,12 @@ public class CommonSupertypes {
|
||||
}
|
||||
Variance projectionKind = variance == IN_VARIANCE ? Variance.INVARIANT : IN_VARIANCE;
|
||||
return new TypeProjection(projectionKind, intersection);
|
||||
} else if (outs != null) {
|
||||
}
|
||||
else if (outs != null) {
|
||||
Variance projectionKind = variance == OUT_VARIANCE ? Variance.INVARIANT : OUT_VARIANCE;
|
||||
return new TypeProjection(projectionKind, commonSupertype(outs));
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
Variance projectionKind = variance == OUT_VARIANCE ? Variance.INVARIANT : OUT_VARIANCE;
|
||||
return new TypeProjection(projectionKind, commonSupertype(parameterDescriptor.getUpperBounds()));
|
||||
}
|
||||
|
||||
@@ -86,7 +86,8 @@ public class DeferredType implements JetType {
|
||||
try {
|
||||
if (lazyValue.isComputed()) {
|
||||
return getActualType().toString();
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
return "<Not computed yet>";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -324,7 +324,8 @@ public class TypeUtils {
|
||||
if (lowerThanBound(typeChecker, argument, parameterDescriptor)) {
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
if (canHaveSubtypes(typeChecker, argument)) {
|
||||
return true;
|
||||
}
|
||||
@@ -335,7 +336,8 @@ public class TypeUtils {
|
||||
if (canHaveSubtypes(typeChecker, argument)) {
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
if (lowerThanBound(typeChecker, argument, parameterDescriptor)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
+12
-6
@@ -201,7 +201,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
|
||||
conditionScope = writableScope;
|
||||
context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(writableScope, function.getFunctionLiteral().getBodyExpression().getStatements(), CoercionStrategy.NO_COERCION, context, context.trace);
|
||||
context.trace.record(BindingContext.BLOCK, function);
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
facade.getType(body, context.replaceScope(context.scope));
|
||||
}
|
||||
}
|
||||
@@ -327,9 +328,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
|
||||
OverloadResolutionResults<FunctionDescriptor> nextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "next", Collections.<JetType>emptyList());
|
||||
if (nextResolutionResults.isAmbiguity()) {
|
||||
context.trace.report(NEXT_AMBIGUITY.on(loopRangeExpression));
|
||||
} else if (nextResolutionResults.isNothing()) {
|
||||
}
|
||||
else if (nextResolutionResults.isNothing()) {
|
||||
context.trace.report(NEXT_MISSING.on(loopRangeExpression));
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
FunctionDescriptor nextFunction = nextResolutionResults.getResultingCall().getResultingDescriptor();
|
||||
context.trace.record(LOOP_RANGE_NEXT, loopRange.getExpression(), nextFunction);
|
||||
return nextFunction.getReturnType();
|
||||
@@ -364,9 +367,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
|
||||
OverloadResolutionResults<FunctionDescriptor> hasNextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "hasNext", Collections.<JetType>emptyList());
|
||||
if (hasNextResolutionResults.isAmbiguity()) {
|
||||
context.trace.report(HAS_NEXT_FUNCTION_AMBIGUITY.on(loopRange));
|
||||
} else if (hasNextResolutionResults.isNothing()) {
|
||||
}
|
||||
else if (hasNextResolutionResults.isNothing()) {
|
||||
return null;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
assert hasNextResolutionResults.isSuccess();
|
||||
JetType hasNextReturnType = hasNextResolutionResults.getResultingDescriptor().getReturnType();
|
||||
if (!isBoolean(hasNextReturnType)) {
|
||||
@@ -381,7 +386,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
|
||||
VariableDescriptor hasNextProperty = DescriptorUtils.filterNonExtensionProperty(iteratorType.getMemberScope().getProperties("hasNext"));
|
||||
if (hasNextProperty == null) {
|
||||
return null;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
JetType hasNextReturnType = hasNextProperty.getType();
|
||||
if (hasNextReturnType == null) {
|
||||
// TODO : accessibility
|
||||
|
||||
+2
-1
@@ -216,7 +216,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
|
||||
if (!JetStandardClasses.isUnit(assignmentOperationType)) {
|
||||
context.trace.report(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT.on(operationSign, assignmentOperationDescriptors.getResultingDescriptor(), operationSign));
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
binaryOperationTrace.commit();
|
||||
context.trace.record(VARIABLE_REASSIGNMENT, expression);
|
||||
if (left instanceof JetArrayAccessExpression) {
|
||||
|
||||
@@ -256,7 +256,8 @@ public class JetStandardClasses {
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
} else if (type.isArray() && type.getComponentType() == ClassDescriptor.class) {
|
||||
}
|
||||
else if (type.isArray() && type.getComponentType() == ClassDescriptor.class) {
|
||||
try {
|
||||
ClassDescriptor[] array = (ClassDescriptor[]) field.get(null);
|
||||
for (ClassDescriptor descriptor : array) {
|
||||
|
||||
@@ -456,7 +456,8 @@ public class DescriptorRenderer implements Renderer<DeclarationDescriptor> {
|
||||
if (!descriptor.equals(JetStandardClasses.getNothing())) {
|
||||
Collection<? extends JetType> supertypes = descriptor.getTypeConstructor().getSupertypes();
|
||||
if (supertypes.isEmpty() || supertypes.size() == 1 && JetStandardClasses.isAny(supertypes.iterator().next())) {
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
builder.append(" : ");
|
||||
for (Iterator<? extends JetType> iterator = supertypes.iterator(); iterator.hasNext(); ) {
|
||||
JetType supertype = iterator.next();
|
||||
|
||||
Reference in New Issue
Block a user