Upgrade JDT in AspectJ to Mars.2 R4_5_Maintenance branch #A7BBA8B15
diff --git a/org.eclipse.jdt.core/META-INF/MANIFEST.MF b/org.eclipse.jdt.core/META-INF/MANIFEST.MF
index 16c0394..21a1907 100644
--- a/org.eclipse.jdt.core/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.core/META-INF/MANIFEST.MF
@@ -3,7 +3,7 @@
Bundle-ManifestVersion: 2
Bundle-Name: %pluginName
Bundle-SymbolicName: org.eclipse.jdt.core; singleton:=true
-Bundle-Version: 3.11.0.qualifier
+Bundle-Version: 3.11.2.qualifier
Bundle-Activator: org.eclipse.jdt.core.JavaCore
Bundle-Vendor: %providerName
Bundle-Localization: plugin
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
index 1c362ea..d4efab1 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
@@ -26,7 +26,7 @@
#Format: compiler.name = word1 word2 word3
compiler.name = Eclipse Compiler for Java(TM)
#Format: compiler.version = (The place holders will be automatically filled. Do not remove or alter it)
-compiler.version = MARS_1007a0215, 3.10.0
+compiler.version = MARS_A7BBA8B15, 3.11.2
compiler.copyright = Copyright IBM Corp 2000, 2015. All rights reserved.
### progress
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
index 0572ffc..7ce5155 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java
@@ -5303,6 +5303,7 @@
char[] typeName = currentType.qualifiedSourceName();
InternalCompletionProposal proposal = createProposal(CompletionProposal.ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
+ proposal.setBinding(constructor);
proposal.setDeclarationSignature(getSignature(currentType));
proposal.setDeclarationKey(currentType.computeUniqueKey());
proposal.setSignature(getSignature(constructor));
@@ -5463,6 +5464,7 @@
char[] typeName = currentType.qualifiedSourceName();
int constructorRelevance = relevance + computeRelevanceForConstructor();
InternalCompletionProposal proposal = createProposal(CompletionProposal.CONSTRUCTOR_INVOCATION, this.actualCompletionPosition);
+ proposal.setBinding(constructor);
proposal.setDeclarationSignature(getSignature(currentType));
proposal.setSignature(getSignature(constructor));
MethodBinding original = constructor.original();
@@ -5506,6 +5508,7 @@
} else {
if(!isIgnored(CompletionProposal.METHOD_REF, missingElements != null) && (this.assistNodeInJavadoc & CompletionOnJavadoc.ONLY_INLINE_TAG) == 0) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(constructor);
proposal.setDeclarationSignature(getSignature(currentType));
proposal.setSignature(getSignature(constructor));
MethodBinding original = constructor.original();
@@ -5547,6 +5550,7 @@
if ((this.assistNodeInJavadoc & CompletionOnJavadoc.TEXT) != 0 && !this.requestor.isIgnored(CompletionProposal.JAVADOC_METHOD_REF)) {
char[] javadocCompletion = inlineTagCompletion(completion, JavadocTagConstants.TAG_LINK);
InternalCompletionProposal proposal = createProposal(CompletionProposal.JAVADOC_METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(constructor);
proposal.setDeclarationSignature(getSignature(currentType));
proposal.setSignature(getSignature(constructor));
MethodBinding original = constructor.original();
@@ -5790,6 +5794,7 @@
if(!this.requestor.isIgnored(CompletionProposal.FIELD_REF)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
@@ -5843,6 +5848,7 @@
ReferenceBinding fieldType = (ReferenceBinding)field.type;
InternalCompletionProposal proposal = createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
@@ -6184,6 +6190,7 @@
this.noProposal = false;
if(!this.requestor.isIgnored(CompletionProposal.METHOD_REF)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(constructor);
proposal.setDeclarationSignature(getSignature(currentType));
proposal.setSignature(getSignature(constructor));
MethodBinding original = constructor.original();
@@ -6417,6 +6424,7 @@
// Standard proposal
if (!this.isIgnored(CompletionProposal.FIELD_REF, missingElements != null) && (this.assistNodeInJavadoc & CompletionOnJavadoc.ONLY_INLINE_TAG) == 0) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
@@ -6451,6 +6459,7 @@
if ((this.assistNodeInJavadoc & CompletionOnJavadoc.TEXT) != 0 && !this.requestor.isIgnored(CompletionProposal.JAVADOC_FIELD_REF)) {
char[] javadocCompletion = inlineTagCompletion(completion, JavadocTagConstants.TAG_LINK);
InternalCompletionProposal proposal = createProposal(CompletionProposal.JAVADOC_FIELD_REF, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
@@ -6493,6 +6502,7 @@
} else {
if(!this.isIgnored(CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER, missingElements != null)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.FIELD_REF_WITH_CASTED_RECEIVER, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setReceiverSignature(getSignature(receiverType));
@@ -7571,6 +7581,7 @@
char[] completion = CharOperation.concat(receiverType.sourceName, field.name, '.');
InternalCompletionProposal proposal = createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
@@ -7613,6 +7624,7 @@
char[] completion = field.name;
InternalCompletionProposal proposal = createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
@@ -7847,6 +7859,7 @@
this.noProposal = false;
if(!this.requestor.isIgnored(CompletionProposal.FIELD_REF)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.FIELD_REF, this.actualCompletionPosition);
+ proposal.setBinding(field);
proposal.setDeclarationSignature(getSignature(field.declaringClass));
proposal.setSignature(getSignature(field.type));
proposal.setDeclarationPackageName(field.declaringClass.qualifiedPackageName());
@@ -8445,6 +8458,7 @@
this.noProposal = false;
if(!this.requestor.isIgnored(CompletionProposal.METHOD_DECLARATION)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_DECLARATION, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setDeclarationKey(method.declaringClass.computeUniqueKey());
proposal.setSignature(getSignature(method));
@@ -8724,6 +8738,7 @@
// Standard proposal
if(!this.isIgnored(CompletionProposal.METHOD_REF, missingElements != null) && (this.assistNodeInJavadoc & CompletionOnJavadoc.ONLY_INLINE_TAG) == 0) {
InternalCompletionProposal proposal = createProposal(completionOnReferenceExpressionName ? CompletionProposal.METHOD_NAME_REFERENCE : CompletionProposal.METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setSignature(getSignature(method));
MethodBinding original = method.original();
@@ -8765,6 +8780,7 @@
if ((this.assistNodeInJavadoc & CompletionOnJavadoc.TEXT) != 0 && !this.requestor.isIgnored(CompletionProposal.JAVADOC_METHOD_REF)) {
char[] javadocCompletion = inlineTagCompletion(completion, JavadocTagConstants.TAG_LINK);
InternalCompletionProposal proposal = createProposal(CompletionProposal.JAVADOC_METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setSignature(getSignature(method));
MethodBinding original = method.original();
@@ -8793,6 +8809,7 @@
} else {
if(!this.isIgnored(CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER, missingElements != null)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_REF_WITH_CASTED_RECEIVER, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setSignature(getSignature(method));
MethodBinding original = method.original();
@@ -8983,6 +9000,7 @@
completion = CharOperation.concat(receiverType.sourceName, completion, '.');
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setSignature(getSignature(method));
MethodBinding original = method.original();
@@ -9012,6 +9030,7 @@
completion = CharOperation.concat(receiverType.sourceName, completion, '.');
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setSignature(getSignature(method));
MethodBinding original = method.original();
@@ -9059,6 +9078,7 @@
} else {
if (!this.isIgnored(CompletionProposal.METHOD_REF, CompletionProposal.METHOD_IMPORT)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setSignature(getSignature(method));
MethodBinding original = method.original();
@@ -9211,6 +9231,7 @@
this.noProposal = false;
if(!this.requestor.isIgnored(CompletionProposal.METHOD_REF)) {
InternalCompletionProposal proposal = createProposal(CompletionProposal.METHOD_REF, this.actualCompletionPosition);
+ proposal.setBinding(method);
proposal.setDeclarationSignature(getSignature(method.declaringClass));
proposal.setSignature(getSignature(method));
MethodBinding original = method.original();
diff --git a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/InternalCompletionProposal.java b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/InternalCompletionProposal.java
index 9e324c5..b2427c4 100644
--- a/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/InternalCompletionProposal.java
+++ b/org.eclipse.jdt.core/codeassist/org/eclipse/jdt/internal/codeassist/InternalCompletionProposal.java
@@ -29,6 +29,9 @@
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.env.IBinaryMethod;
import org.eclipse.jdt.internal.compiler.env.IBinaryType;
+import org.eclipse.jdt.internal.compiler.lookup.Binding;
+import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
+import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.core.BinaryType;
import org.eclipse.jdt.internal.core.JavaElement;
import org.eclipse.jdt.internal.core.JavaModelManager;
@@ -134,6 +137,13 @@
private char[] name = null;
/**
+ * Binding of the method or constructor being proposed, or
+ * <code>null</code> if none.
+ * Defaults to null.
+ */
+ private Binding binding = null;
+
+ /**
* Signature of the method, field type, member type,
* relevant in the context, or <code>null</code> if none.
* Defaults to null.
@@ -907,6 +917,45 @@
}
/**
+ * Returns a binding of the method or field corresponding to this proposal or <code>null</code> if none.
+ * <p>
+ * The binding <em>may</em> be available for the following kinds of completion proposals:
+ * <ul>
+ * <li><code>ANONYMOUS_CLASS_CONSTRUCTOR_INVOCATION</code> - {@link MethodBinding}
+ * of the constructor being proposed</li>
+ * <li><code>CONSTRUCTOR_INVOCATION</code> - {@link MethodBinding}
+ * of the constructor being proposed</li>
+ * <li><code>FIELD_REF</code> - {@link FieldBinding}
+ * of the field being proposed</li>
+ * <li><code>FIELD_REF_WITH_CASTED_RECEIVER</code> - {@link FieldBinding}
+ * of the field being proposed</li>
+ * <li><code>JAVADOC_FIELD_REF</code> - {@link FieldBinding}
+ * of the field being proposed</li>
+ * <li><code>JAVADOC_METHOD_REF</code> - {@link MethodBinding}
+ * of the method or constructor being proposed</li>
+ * <li><code>METHOD_DECLARATION</code> - {@link MethodBinding}
+ * of the method or constructor being proposed</li>
+ * <li><code>METHOD_NAME_REFERENCE</code> - {@link MethodBinding}
+ * of the method or constructor being proposed</li>
+ * <li><code>METHOD_REF</code> - {@link MethodBinding}
+ * of the method or constructor being proposed</li>
+ * <li><code>METHOD_REF_WITH_CASTED_RECEIVER</code> - {@link MethodBinding}
+ * of the method or constructor being proposed</li>
+ * </ul>
+ * For other kinds of completion proposals, this method returns <code>null</code>.
+ * </p>
+ *
+ * @return the binding corresponding to this proposal (if available), or <code>null</code> if none
+ */
+ public Binding getBinding() {
+ return this.binding;
+ }
+
+ public void setBinding(Binding binding) {
+ this.binding = binding;
+ }
+
+ /**
* Returns the signature of the method or type
* relevant in the context, or <code>null</code> if none.
* <p>
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java
index 6d049f8..0d4d89b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java
@@ -273,7 +273,7 @@
// perform some emulation work in case there is some and we are inside a local type only
if (allocatedTypeErasure.isNestedType()
- && (currentScope.enclosingSourceType().isLocalType() || currentScope.isLambdaScope())) {
+ && (currentScope.enclosingSourceType().isLocalType() || currentScope.isLambdaSubscope())) {
if (allocatedTypeErasure.isLocalType()) {
((LocalTypeBinding) allocatedTypeErasure).addInnerEmulationDependent(currentScope, false);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
index 23fd4a3..94b8b08 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java
@@ -21,6 +21,7 @@
* Bug 429958 - [1.8][null] evaluate new DefaultLocation attribute of @NonNullByDefault
* Bug 435805 - [1.8][compiler][null] Java 8 compiler does not recognize declaration style null annotations
* Bug 457210 - [1.8][compiler][null] Wrong Nullness errors given on full build build but not on incremental build?
+ * Bug 469584 - ClassCastException in Annotation.detectStandardAnnotation (320)
* Andy Clement (GoPivotal, Inc) aclement@gopivotal.com - Contributions for
* Bug 383624 - [1.8][compiler] Revive code generation support for type annotations (from Olivier's work)
* Bug 409517 - [1.8][compiler] Type annotation problems on more elaborate array references
@@ -319,13 +320,11 @@
case TypeIds.T_JavaLangAnnotationRetention :
if (valueAttribute != null) {
Expression expr = valueAttribute.value;
- if ((expr.bits & Binding.VARIABLE) == Binding.FIELD) {
- if (expr instanceof Reference) { // New AspectJ Extension (pr148537)
+ if ((expr.bits & Binding.VARIABLE) == Binding.FIELD && expr instanceof Reference) { // anything but Reference would be a type error anyway
FieldBinding field = ((Reference)expr).fieldBinding();
if (field != null && field.declaringClass.id == T_JavaLangAnnotationRetentionPolicy) {
tagBits |= getRetentionPolicy(field.name);
}
- } // New AspectJ Extension - end of if()
}
}
break;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/DoStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/DoStatement.java
index 4f9cd46..cc61fc0 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/DoStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/DoStatement.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java
index 89f4b72..1beec31 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java
@@ -34,6 +34,7 @@
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.jdt.internal.compiler.lookup.CaptureBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
@@ -424,6 +425,11 @@
TypeBinding expectedCollectionType = null;
if (elementType != null && collectionType != null) {
boolean isTargetJsr14 = this.scope.compilerOptions().targetJDK == ClassFileConstants.JDK1_4;
+ if (collectionType.isCapture()) {
+ TypeBinding upperBound = ((CaptureBinding)collectionType).firstBound;
+ if (upperBound.isArrayType())
+ collectionType = upperBound; // partially anticipating the fix for https://bugs.openjdk.java.net/browse/JDK-8013843
+ }
if (collectionType.isArrayType()) { // for(E e : E[])
this.kind = ARRAY;
this.collectionElementType = ((ArrayBinding) collectionType).elementsType();
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
index 8fc1d41..a615681 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LambdaExpression.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2012, 2014 IBM Corporation and others.
+ * Copyright (c) 2012, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -36,6 +36,7 @@
* Bug 452788 - [1.8][compiler] Type not correctly inferred in lambda expression
* Bug 453483 - [compiler][null][loop] Improve null analysis for loops
* Bug 455723 - Nonnull argument not correctly inferred in loop
+ * Bug 463728 - [1.8][compiler][inference] Ternary operator in lambda derives wrong type
* Andy Clement (GoPivotal, Inc) aclement@gopivotal.com - Contributions for
* Bug 405104 - [1.8][compiler][codegen] Implement support for serializeable lambdas
*******************************************************************************/
@@ -424,6 +425,8 @@
if (this.body instanceof Expression) {
Expression expression = (Expression) this.body;
new ReturnStatement(expression, expression.sourceStart, expression.sourceEnd, true).resolve(this.scope); // :-) ;-)
+ if (expression.resolvedType == TypeBinding.VOID && !expression.statementExpression())
+ this.scope.problemReporter().invalidExpressionAsStatement(expression);
} else {
this.body.resolve(this.scope);
/* At this point, shape analysis is complete for ((see returnsExpression(...))
@@ -981,13 +984,11 @@
this.returnsValue = true;
this.voidCompatible = false;
this.valueCompatible = !this.returnsVoid;
- if (resultType != null) {
- Expression [] returnExpressions = this.resultExpressions;
- int resultsLength = returnExpressions.length;
- System.arraycopy(returnExpressions, 0, returnExpressions = new Expression[resultsLength + 1], 0, resultsLength);
- returnExpressions[resultsLength] = expression;
- this.resultExpressions = returnExpressions;
- }
+ Expression [] returnExpressions = this.resultExpressions;
+ int resultsLength = returnExpressions.length;
+ System.arraycopy(returnExpressions, 0, returnExpressions = new Expression[resultsLength + 1], 0, resultsLength);
+ returnExpressions[resultsLength] = expression;
+ this.resultExpressions = returnExpressions;
} else {
this.returnsVoid = true;
this.valueCompatible = false;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java
index 7f1eb02..c738446 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java
@@ -52,6 +52,7 @@
* Bug 452788 - [1.8][compiler] Type not correctly inferred in lambda expression
* Bug 456487 - [1.8][null] @Nullable type variant of @NonNull-constrained type parameter causes grief
* Bug 407414 - [compiler][null] Incorrect warning on a primitive type being null
+ * Bug 470958 - [1.8] Unable to convert lambda
* Jesper S Moller - Contributions for
* Bug 378674 - "The method can be declared as static" is wrong
* Andy Clement (GoPivotal, Inc) aclement@gopivotal.com - Contributions for
@@ -82,6 +83,7 @@
import org.eclipse.jdt.internal.compiler.lookup.IPrivilegedHandler;
import org.eclipse.jdt.internal.compiler.lookup.ImplicitNullAnnotationVerifier;
import org.eclipse.jdt.internal.compiler.lookup.InferenceContext18;
+import org.eclipse.jdt.internal.compiler.lookup.InferenceVariable;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.MissingTypeBinding;
@@ -472,7 +474,7 @@
codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessor, null /* default declaringClass */, this.typeArguments);
} else {
codeStream.invoke(Opcodes.OPC_invokevirtual, this.syntheticAccessor, null /* default declaringClass */, this.typeArguments);
- }
+ }
// End AspectJ extension
}
// required cast must occur even if no value is required
@@ -663,6 +665,9 @@
// scope.problemReporter().genericInferenceError("Receiver was unexpectedly found resolved", this); //$NON-NLS-1$
// AspectJ Extension: End
this.actualReceiverType = this.receiver.resolveType(scope);
+ if (this.actualReceiverType instanceof InferenceVariable) {
+ return null; // not yet ready for resolving
+ }
this.receiverIsType = this.receiver instanceof NameReference && (((NameReference) this.receiver).bits & Binding.TYPE) != 0;
if (receiverCast && this.actualReceiverType != null) {
// due to change of declaring class with receiver type, only identity cast should be notified
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java
index 8f590f7..ccaa1ce 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/NullAnnotationMatching.java
@@ -85,6 +85,7 @@
public static int checkAssignment(BlockScope currentScope, FlowContext flowContext,
VariableBinding var, FlowInfo flowInfo, int nullStatus, Expression expression, TypeBinding providedType)
{
+ if (providedType == null) return FlowInfo.UNKNOWN; // assume we already reported an error
long lhsTagBits = 0L;
boolean hasReported = false;
if (!currentScope.environment().usesNullTypeAnnotations()) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java
index ff66190..416812e 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -256,7 +256,7 @@
// perform some extra emulation work in case there is some and we are inside a local type only
if (allocatedTypeErasure.isNestedType()
- && (currentScope.enclosingSourceType().isLocalType() || currentScope.isLambdaScope())) {
+ && (currentScope.enclosingSourceType().isLocalType() || currentScope.isLambdaSubscope())) {
if (allocatedTypeErasure.isLocalType()) {
((LocalTypeBinding) allocatedTypeErasure).addInnerEmulationDependent(currentScope, this.enclosingInstance != null);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java
index 6df8946..2343f42 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReferenceExpression.java
@@ -36,6 +36,7 @@
* Bug 448709 - [1.8][null] ensure we don't infer types that violate null constraints on a type parameter's bound
* Bug 459967 - [null] compiler should know about nullness of special methods like MyEnum.valueOf()
* Bug 466713 - Null Annotations: NullPointerException using <int @Nullable []> as Type Param
+ * Bug 470542 - NullPointerException in ReferenceExpression.isPotentiallyCompatibleWith (962)
* Andy Clement (GoPivotal, Inc) aclement@gopivotal.com - Contribution for
* Bug 383624 - [1.8][compiler] Revive code generation support for type annotations (from Olivier's work)
*******************************************************************************/
@@ -843,7 +844,11 @@
return null;
int n = functionType.parameters.length;
int k = this.exactMethodBinding.parameters.length;
- return (n == k || n == k + 1) ? this : null;
+
+ if (!this.haveReceiver && this.isMethodReference() && !this.exactMethodBinding.isStatic()) {
+ k++;
+ }
+ return (n == k) ? this : null;
}
// descriptors parameters should be free of inference variables.
ReferenceExpression copy = cachedResolvedCopy(targetType);
@@ -959,12 +964,16 @@
public boolean isPotentiallyCompatibleWith(TypeBinding targetType, Scope scope) {
final boolean isConstructorRef = isConstructorReference();
- if (isConstructorRef && this.receiverType.isArrayType()) {
+ if (isConstructorRef) {
+ if (this.receiverType == null)
+ return false;
+ if (this.receiverType.isArrayType()) {
final TypeBinding leafComponentType = this.receiverType.leafComponentType();
if (!leafComponentType.isReifiable()) {
return false;
}
}
+ }
// We get here only when the reference expression is NOT pertinent to applicability.
if (!super.isPertinentToApplicability(targetType, null))
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java
index 07cd801..f8fc493 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java
index ed80d9b..aafe24b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/NonNullDefaultAwareTypeAnnotationWalker.java
@@ -109,6 +109,12 @@
}
@Override
+ public ITypeAnnotationWalker toSupertype(short index, char[] superTypeSignature) {
+ if (this.isEmpty) return restrict(this.matches, this.pathPtr);
+ return super.toSupertype(index, superTypeSignature);
+ }
+
+ @Override
public ITypeAnnotationWalker toMethodParameter(short index) {
// don't set nextIsDefaultLocation, because signature-level nullness is handled by ImplicitNullAnnotationVerifier
if (this.isEmpty) return restrict(this.matches, this.pathPtr);
@@ -131,6 +137,14 @@
}
@Override
+ public ITypeAnnotationWalker toWildcardBound() {
+ this.nextIsDefaultLocation = (this.defaultNullness & Binding.DefaultLocationTypeBound) != 0;
+ this.nextIsTypeBound = true;
+ if (this.isEmpty) return restrict(this.matches, this.pathPtr);
+ return super.toWildcardBound();
+ }
+
+ @Override
public ITypeAnnotationWalker toTypeParameterBounds(boolean isClassTypeParameter, int parameterRank) {
this.nextIsDefaultLocation = (this.defaultNullness & Binding.DefaultLocationTypeBound) != 0;
this.nextIsTypeBound = true;
@@ -155,6 +169,12 @@
}
@Override
+ protected ITypeAnnotationWalker toNextDetail(int detailKind) {
+ if (this.isEmpty) return restrict(this.matches, this.pathPtr);
+ return super.toNextDetail(detailKind);
+ }
+
+ @Override
public IBinaryAnnotation[] getAnnotationsAtCursor(int currentTypeId) {
IBinaryAnnotation[] normalAnnotations = this.isEmpty ? null : super.getAnnotationsAtCursor(currentTypeId);
if (this.atDefaultLocation &&
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
index d0cf15e..96ada5b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -65,10 +65,6 @@
public static final int LABELS_INCREMENT = 5;
// local variable attributes output
public static final int LOCALS_INCREMENT = 10;
- static ExceptionLabel[] noExceptionHandlers = new ExceptionLabel[LABELS_INCREMENT];
- static BranchLabel[] noLabels = new BranchLabel[LABELS_INCREMENT];
- static LocalVariableBinding[] noLocals = new LocalVariableBinding[LOCALS_INCREMENT];
- static LocalVariableBinding[] noVisibleLocals = new LocalVariableBinding[LOCALS_INCREMENT];
public static final CompilationResult RESTART_IN_WIDE_MODE = new CompilationResult((char[])null, 0, 0, 0);
public static final CompilationResult RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE = new CompilationResult((char[])null, 0, 0, 0);
@@ -4115,32 +4111,12 @@
this.startingClassFileOffset = this.classFileOffset;
this.pcToSourceMapSize = 0;
this.lastEntryPC = 0;
- int length = this.visibleLocals.length;
- if (noVisibleLocals.length < length) {
- noVisibleLocals = new LocalVariableBinding[length];
- }
- System.arraycopy(noVisibleLocals, 0, this.visibleLocals, 0, length);
this.visibleLocalsCount = 0;
- length = this.locals.length;
- if (noLocals.length < length) {
- noLocals = new LocalVariableBinding[length];
- }
- System.arraycopy(noLocals, 0, this.locals, 0, length);
this.allLocalsCounter = 0;
- length = this.exceptionLabels.length;
- if (noExceptionHandlers.length < length) {
- noExceptionHandlers = new ExceptionLabel[length];
- }
- System.arraycopy(noExceptionHandlers, 0, this.exceptionLabels, 0, length);
this.exceptionLabelsCounter = 0;
- length = this.labels.length;
- if (noLabels.length < length) {
- noLabels = new BranchLabel[length];
- }
- System.arraycopy(noLabels, 0, this.labels, 0, length);
this.countLabels = 0;
this.lastAbruptCompletion = -1;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationBinding.java
index 02070bd..cfd1fa7 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/AnnotationBinding.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -245,7 +245,12 @@
}
public int hashCode() {
- return this.type.hashCode();
+ int result = 17;
+ int c = this.type.hashCode();
+ result = 31 * result + c;
+ c = Arrays.hashCode(this.pairs);
+ result = 31 * result + c;
+ return result;
}
public boolean equals(Object object) {
if (this == object)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
index edefccf..67a5b6a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java
@@ -34,6 +34,7 @@
* Bug 435805 - [1.8][compiler][null] Java 8 compiler does not recognize declaration style null annotations
* Bug 453475 - [1.8][null] Contradictory null annotations (4.5 M3 edition)
* Bug 454182 - Internal compiler error when using 1.8 compliance for simple project
+ * Bug 447661 - [1.8][null] Incorrect 'expression needs unchecked conversion' warning
* Jesper Steen Moller - Contributions for
* Bug 412150 [1.8] [compiler] Enable reflected parameter names during annotation processing
* Bug 412153 - [1.8][compiler] Check validity of annotations which may be repeatable
@@ -412,7 +413,7 @@
// need annotations on the type before processing null annotations on members respecting any @NonNullByDefault:
scanTypeForNullDefaultAnnotation(binaryType, this.fPackage);
}
- ITypeAnnotationWalker walker = getTypeAnnotationWalker(binaryType.getTypeAnnotations());
+ ITypeAnnotationWalker walker = getTypeAnnotationWalker(binaryType.getTypeAnnotations(), Binding.NO_NULL_DEFAULT);
ITypeAnnotationWalker toplevelWalker = binaryType.enrichWithExternalAnnotationsFor(walker, null, this.environment);
char[] typeSignature = binaryType.getGenericSignature(); // use generic signature even in 1.4
this.tagBits |= binaryType.getTagBits();
@@ -533,24 +534,38 @@
}
}
-private ITypeAnnotationWalker getTypeAnnotationWalker(IBinaryTypeAnnotation[] annotations) {
+/* When creating a method we need to pass in any default 'nullness' from a @NNBD immediately on this method. */
+private ITypeAnnotationWalker getTypeAnnotationWalker(IBinaryTypeAnnotation[] annotations, int nullness) {
if (!isPrototype()) throw new IllegalStateException();
if (annotations == null || annotations.length == 0 || !this.environment.usesAnnotatedTypeSystem()) {
if (this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
- int nullness = getNullDefault();
+ if (nullness == Binding.NO_NULL_DEFAULT)
+ nullness = getNullDefault();
if (nullness > Binding.NULL_UNSPECIFIED_BY_DEFAULT)
return new NonNullDefaultAwareTypeAnnotationWalker(nullness, this.environment);
}
return ITypeAnnotationWalker.EMPTY_ANNOTATION_WALKER;
}
if (this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
- int nullness = getNullDefault();
+ if (nullness == Binding.NO_NULL_DEFAULT)
+ nullness = getNullDefault();
if (nullness > Binding.NULL_UNSPECIFIED_BY_DEFAULT)
return new NonNullDefaultAwareTypeAnnotationWalker(annotations, nullness, this.environment);
}
return new TypeAnnotationWalker(annotations);
}
+private int getNullDefaultFrom(IBinaryAnnotation[] declAnnotations) {
+ if (declAnnotations != null) {
+ char[][] nonNullByDefaultAnnotationName = this.environment.getNonNullByDefaultAnnotationName();
+ for (IBinaryAnnotation annotation : declAnnotations) {
+ char[][] typeName = signature2qualifiedTypeName(annotation.getTypeName());
+ if (CharOperation.equals(typeName, nonNullByDefaultAnnotationName))
+ return getNonNullByDefaultValue(annotation);
+ }
+ }
+ return Binding.NO_NULL_DEFAULT;
+}
private void createFields(IBinaryField[] iFields, IBinaryType binaryType, long sourceLevel, char[][][] missingTypeNames) {
if (!isPrototype()) throw new IllegalStateException();
@@ -565,7 +580,7 @@
for (int i = 0; i < size; i++) {
IBinaryField binaryField = iFields[i];
char[] fieldSignature = use15specifics ? binaryField.getGenericSignature() : null;
- ITypeAnnotationWalker walker = getTypeAnnotationWalker(binaryField.getTypeAnnotations());
+ ITypeAnnotationWalker walker = getTypeAnnotationWalker(binaryField.getTypeAnnotations(), Binding.NO_NULL_DEFAULT);
if (sourceLevel >= ClassFileConstants.JDK1_8) { // below 1.8, external annotations will be attached later
walker = binaryType.enrichWithExternalAnnotationsFor(walker, iFields[i], this.environment);
}
@@ -637,7 +652,7 @@
variables properly in order to be able to apply substitutions and thus be able to detect
overriding in the presence of generics. Seeing the erased form is not good enough.
*/
- ITypeAnnotationWalker walker = getTypeAnnotationWalker(method.getTypeAnnotations());
+ ITypeAnnotationWalker walker = getTypeAnnotationWalker(method.getTypeAnnotations(), getNullDefaultFrom(method.getAnnotations()));
char[] methodSignature = method.getGenericSignature(); // always use generic signature, even in 1.4
if (methodSignature == null) { // no generics
char[] methodDescriptor = method.getMethodDescriptor(); // of the form (I[Ljava/jang/String;)V
@@ -1593,7 +1608,7 @@
char[] annotationTypeName = annotations[i].getTypeName();
if (annotationTypeName[0] != Util.C_RESOLVED)
continue;
- char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
+ char[][] typeName = signature2qualifiedTypeName(annotationTypeName);
if (CharOperation.equals(typeName, nonNullAnnotationName)) {
fieldBinding.tagBits |= TagBits.AnnotationNonNull;
explicitNullness = true;
@@ -1629,7 +1644,7 @@
char[] annotationTypeName = annotations[i].getTypeName();
if (annotationTypeName[0] != Util.C_RESOLVED)
continue;
- char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
+ char[][] typeName = signature2qualifiedTypeName(annotationTypeName);
if (CharOperation.equals(typeName, nonNullByDefaultAnnotationName)) {
methodBinding.defaultNullness = getNonNullByDefaultValue(annotations[i]);
if (methodBinding.defaultNullness == Binding.NULL_UNSPECIFIED_BY_DEFAULT)
@@ -1663,7 +1678,7 @@
char[] annotationTypeName = paramAnnotations[i].getTypeName();
if (annotationTypeName[0] != Util.C_RESOLVED)
continue;
- char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
+ char[][] typeName = signature2qualifiedTypeName(annotationTypeName);
if (CharOperation.equals(typeName, nonNullAnnotationName)) {
if (methodBinding.parameterNonNullness == null)
methodBinding.parameterNonNullness = new Boolean[numVisibleParams];
@@ -1701,7 +1716,7 @@
char[] annotationTypeName = annotations[i].getTypeName();
if (annotationTypeName[0] != Util.C_RESOLVED)
continue;
- char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
+ char[][] typeName = signature2qualifiedTypeName(annotationTypeName);
if (CharOperation.equals(typeName, nonNullByDefaultAnnotationName)) {
// using NonNullByDefault we need to inspect the details of the value() attribute:
nullness = getNonNullByDefaultValue(annotations[i]);
@@ -1767,7 +1782,7 @@
// pre: null annotation analysis is enabled
int getNonNullByDefaultValue(IBinaryAnnotation annotation) {
char[] annotationTypeName = annotation.getTypeName();
- char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
+ char[][] typeName = signature2qualifiedTypeName(annotationTypeName);
IBinaryElementValuePair[] elementValuePairs = annotation.getElementValuePairs();
if (elementValuePairs == null || elementValuePairs.length == 0 ) {
// no argument: apply default default
@@ -1793,6 +1808,10 @@
}
}
+private char[][] signature2qualifiedTypeName(char[] typeSignature) {
+ return CharOperation.splitOn('/', typeSignature, 1, typeSignature.length-1); // cut off leading 'L' and trailing ';'
+}
+
@Override
int getNullDefault() {
return this.defaultNullness;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java
index e75257a..dc660b7 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintExpressionFormula.java
@@ -23,6 +23,7 @@
import org.eclipse.jdt.internal.compiler.ast.ExpressionContext;
import org.eclipse.jdt.internal.compiler.ast.Invocation;
import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
+import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.ReferenceExpression;
import org.eclipse.jdt.internal.compiler.lookup.InferenceContext18.SuspendedInferenceRecord;
@@ -67,8 +68,11 @@
}
if (!canBePolyExpression(this.left)) {
TypeBinding exprType = this.left.resolvedType;
- if (exprType == null || !exprType.isValidBinding())
+ if (exprType == null || !exprType.isValidBinding()) {
+ if (this.left instanceof MessageSend && ((MessageSend)this.left).actualReceiverType instanceof InferenceVariable)
+ return null; // nothing valuable to infer from this
return FALSE;
+ }
return ConstraintTypeFormula.create(exprType, this.right, COMPATIBLE, this.isSoft);
} else {
// shapes of poly expressions (18.2.1)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintTypeFormula.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintTypeFormula.java
index 5ea33a7..360a5ab 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintTypeFormula.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ConstraintTypeFormula.java
@@ -64,14 +64,10 @@
return this.left.isCompatibleWith(this.right, inferenceContext.scope) || this.left.isBoxingCompatibleWith(this.right, inferenceContext.scope) ? TRUE : FALSE;
}
if (this.left.isPrimitiveType()) {
- if (inferenceContext.inferenceKind == InferenceContext18.CHECK_STRICT)
- inferenceContext.inferenceKind = InferenceContext18.CHECK_LOOSE;
TypeBinding sPrime = inferenceContext.environment.computeBoxingType(this.left);
return ConstraintTypeFormula.create(sPrime, this.right, COMPATIBLE, this.isSoft);
}
if (this.right.isPrimitiveType()) {
- if (inferenceContext.inferenceKind == InferenceContext18.CHECK_STRICT)
- inferenceContext.inferenceKind = InferenceContext18.CHECK_LOOSE;
TypeBinding tPrime = inferenceContext.environment.computeBoxingType(this.right);
return ConstraintTypeFormula.create(this.left, tPrime, SAME, this.isSoft);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
index 0e06744..7688a6c 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java
@@ -14,6 +14,7 @@
* Bug 447088 - [null] @Nullable on fully qualified field type is ignored
* Bug 435805 - [1.8][compiler][null] Java 8 compiler does not recognize declaration style null annotations
* Bug 458396 - NPE in CodeStream.invoke()
+ * Bug 446217 - [null] @NonNullByDefault in package-info.java causes bogus "null type safety" warning
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;
@@ -245,8 +246,11 @@
public void fillInDefaultNonNullness(FieldDeclaration sourceField, Scope scope) {
LookupEnvironment environment = scope.environment();
- if ( this.type != null
- && !this.type.isBaseType()
+ if (this.type == null)
+ return;
+ if (environment.usesNullTypeAnnotations() && !this.type.acceptsNonNullDefault())
+ return;
+ if ( !this.type.isBaseType()
&& (this.tagBits & TagBits.AnnotationNullMASK) == 0 // declaration annotation?
&& (this.type.tagBits & TagBits.AnnotationNullMASK) == 0) // type annotation? (java.lang.@Nullable String)
{
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java
index 384b4b5..4057cee 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ImplicitNullAnnotationVerifier.java
@@ -269,7 +269,7 @@
break returnType; // compatible by construction, skip complain phase below
}
}
- if (hasReturnNonNullDefault && currentMethod.returnType.acceptsNonNullDefault()) { // conflict with inheritance already checked
+ if (hasReturnNonNullDefault && (!useTypeAnnotations || currentMethod.returnType.acceptsNonNullDefault())) { // conflict with inheritance already checked
currentNullnessBits = TagBits.AnnotationNonNull;
applyReturnNullBits(currentMethod, currentNullnessBits);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java
index e28b06d..dd33dbb 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext18.java
@@ -493,6 +493,10 @@
if (withWildCards != null) {
t = ConstraintExpressionFormula.findGroundTargetType(this, skope, lambda, withWildCards);
}
+ if (!t.isProperType(true) && t.isParameterizedType()) {
+ // prevent already resolved inference variables from leaking into the lambda
+ t = (ReferenceBinding) Scope.substitute(getResultSubstitution(this.currentBounds, false), t);
+ }
MethodBinding functionType;
if (t != null && (functionType = t.getSingleAbstractMethod(skope, true)) != null && (lambda = lambda.resolveExpressionExpecting(t, this.scope, this)) != null) {
TypeBinding r = functionType.returnType;
@@ -1106,14 +1110,29 @@
* on any uninstantiated variable outside the set.
*/
private Set<InferenceVariable> getSmallestVariableSet(BoundSet bounds, InferenceVariable[] subSet) {
+ // "Given a set of inference variables to resolve, let V be the union of this set and
+ // all variables upon which the resolution of at least one variable in this set depends."
+ Set<InferenceVariable> v = new HashSet<InferenceVariable>();
+ Map<InferenceVariable,Set<InferenceVariable>> dependencies = new HashMap<>(); // compute only once, store for the final loop over 'v'.
+ for (InferenceVariable iv : subSet) {
+ Set<InferenceVariable> tmp = new HashSet<>();
+ addDependencies(bounds, tmp, iv);
+ dependencies.put(iv, tmp);
+ v.addAll(tmp);
+ }
+ // "If every variable in V has an instantiation, then resolution succeeds and this procedure terminates."
+ // -> (implicit if result remains unassigned)
+ // "Otherwise, let { α1, ..., αn } be a non-empty subset of uninstantiated variables in V such that ...
int min = Integer.MAX_VALUE;
Set<InferenceVariable> result = null;
- for (int i = 0; i < subSet.length; i++) {
- InferenceVariable currentVariable = subSet[i];
+ // "i) for all i (1 ≤ i ≤ n), ..."
+ for (InferenceVariable currentVariable : v) {
if (!bounds.isInstantiated(currentVariable)) {
- Set<InferenceVariable> set = new HashSet<InferenceVariable>();
- if (!addDependencies(bounds, set, currentVariable, min))
- continue;
+ // "... if αi depends on the resolution of a variable β, then either β has an instantiation or there is some j such that β = αj; ..."
+ Set<InferenceVariable> set = dependencies.get(currentVariable);
+ if (set == null) // not an element of the original subSet, still need to fetch this var's dependencies
+ addDependencies(bounds, set = new HashSet<>(), currentVariable);
+ // "... and ii) there exists no non-empty proper subset of { α1, ..., αn } with this property."
int cur = set.size();
if (cur == 1)
return set; // won't get smaller
@@ -1126,19 +1145,15 @@
return result;
}
- private boolean addDependencies(BoundSet boundSet, Set<InferenceVariable> variableSet, InferenceVariable currentVariable, int min) {
- if (variableSet.size() >= min)
- return false; // no improvement
- if (boundSet.isInstantiated(currentVariable)) return true; // not added
- if (!variableSet.add(currentVariable)) return true; // already present
+ private void addDependencies(BoundSet boundSet, Set<InferenceVariable> variableSet, InferenceVariable currentVariable) {
+ if (boundSet.isInstantiated(currentVariable)) return; // not added
+ if (!variableSet.add(currentVariable)) return; // already present
for (int j = 0; j < this.inferenceVariables.length; j++) {
InferenceVariable nextVariable = this.inferenceVariables[j];
if (TypeBinding.equalsEquals(nextVariable, currentVariable)) continue;
if (boundSet.dependsOnResolutionOf(currentVariable, nextVariable))
- if (!addDependencies(boundSet, variableSet, nextVariable, min))
- return false; // abort traversal: no improvement
+ addDependencies(boundSet, variableSet, nextVariable);
}
- return true;
}
private ConstraintFormula pickFromCycle(Set<ConstraintFormula> c) {
@@ -1398,7 +1413,7 @@
this.usesUncheckedConversion = record.usesUncheckedConversion;
}
- private Substitution getResultSubstitution(final BoundSet result) {
+ private Substitution getResultSubstitution(final BoundSet result, final boolean full) {
return new Substitution() {
public LookupEnvironment environment() {
return InferenceContext18.this.environment;
@@ -1408,7 +1423,9 @@
}
public TypeBinding substitute(TypeVariableBinding typeVariable) {
if (typeVariable instanceof InferenceVariable) {
- return result.getInstantiation((InferenceVariable) typeVariable, InferenceContext18.this.environment);
+ TypeBinding instantiation = result.getInstantiation((InferenceVariable) typeVariable, InferenceContext18.this.environment);
+ if (instantiation != null || full)
+ return instantiation;
}
return typeVariable;
}
@@ -1533,7 +1550,7 @@
void reportUncheckedConversions(BoundSet solution) {
if (this.constraintsWithUncheckedConversion != null) {
int len = this.constraintsWithUncheckedConversion.size();
- Substitution substitution = getResultSubstitution(solution);
+ Substitution substitution = getResultSubstitution(solution, true);
for (int i = 0; i < len; i++) {
ConstraintTypeFormula constraint = (ConstraintTypeFormula) this.constraintsWithUncheckedConversion.get(i);
TypeBinding expectedType = constraint.right;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
index 01aac01..57a81d9 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
@@ -25,6 +25,8 @@
* Bug 443347 - [1.8][null] @NonNullByDefault should not affect constructor arguments of an anonymous instantiation
* Bug 435805 - [1.8][compiler][null] Java 8 compiler does not recognize declaration style null annotations
* Bug 466713 - Null Annotations: NullPointerException using <int @Nullable []> as Type Param
+ * Bug 456584 - [1.8][null] Bogus warning for return type variable's @NonNull annotation being 'redundant'
+ * Bug 471611 - Error on hover on call to generic method with null annotation
* Jesper Steen Moller - Contributions for
* Bug 412150 [1.8] [compiler] Enable reflected parameter names during annotation processing
*******************************************************************************/
@@ -589,8 +591,8 @@
if (added)
this.tagBits |= TagBits.HasParameterAnnotations;
}
- if (this.returnType != null && hasNonNullDefaultFor(DefaultLocationReturnType, true)) {
- if (this.returnType.acceptsNonNullDefault() && (this.returnType.tagBits & TagBits.AnnotationNullMASK) == 0) {
+ if (this.returnType != null && hasNonNullDefaultFor(DefaultLocationReturnType, true) && this.returnType.acceptsNonNullDefault()) {
+ if ((this.returnType.tagBits & TagBits.AnnotationNullMASK) == 0) {
this.returnType = env.createAnnotatedType(this.returnType, new AnnotationBinding[]{env.getNonNullAnnotation()});
} else if (sourceMethod instanceof MethodDeclaration && (this.returnType.tagBits & TagBits.AnnotationNonNull) != 0
&& ((MethodDeclaration)sourceMethod).hasNullTypeAnnotation(AnnotationPosition.MAIN_TYPE)) {
@@ -742,7 +744,7 @@
if (this.declaringClass instanceof SourceTypeBinding) {
SourceTypeBinding sourceType = (SourceTypeBinding) this.declaringClass;
if (sourceType.scope != null) {
- AbstractMethodDeclaration methodDecl = sourceType.scope.referenceType().declarationOf(this);
+ AbstractMethodDeclaration methodDecl = sourceType.scope.referenceType().declarationOf(originalMethod);
for (int i = 0; i < length; i++) {
Argument argument = methodDecl.arguments[i];
if (argument.annotations != null) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
index 32b1b07..81d184f 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2015 IBM Corporation and others.
+ * Copyright (c) 2000, 2016 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -95,7 +95,13 @@
this.rank = prototype.rank;
this.firstBound = prototype.firstBound;
this.superclass = prototype.superclass;
- this.superInterfaces = prototype.superInterfaces;
+ if (prototype.superInterfaces != null) {
+ int len = prototype.superInterfaces.length;
+ if (len > 0)
+ System.arraycopy(prototype.superInterfaces, 0, this.superInterfaces = new ReferenceBinding[len], 0, len);
+ else
+ this.superInterfaces = Binding.NO_SUPERINTERFACES;
+ }
this.genericTypeSignature = prototype.genericTypeSignature;
this.environment = prototype.environment;
prototype.tagBits |= TagBits.HasAnnotatedVariants;
@@ -244,13 +250,11 @@
}
public int boundsCount() {
- if (this.firstBound == null) {
+ if (this.firstBound == null)
return 0;
- } else if (TypeBinding.equalsEquals(this.firstBound, this.superclass)) {
- return this.superInterfaces.length + 1;
- } else {
- return this.superInterfaces.length;
- }
+ if (this.firstBound.isInterface())
+ return this.superInterfaces.length; // only interface bounds
+ return this.superInterfaces.length + 1; // class or array type isn't contained in superInterfaces
}
/**
@@ -421,10 +425,11 @@
if (n == 0)
return NO_TYPE_BOUNDS;
TypeBound[] bounds = new TypeBound[n];
- bounds[0] = TypeBound.createBoundOrDependency(theta, this.firstBound, variable);
- int ifcOffset = TypeBinding.equalsEquals(this.firstBound, this.superclass) ? -1 : 0;
- for (int i = 1; i < n; i++)
- bounds[i] = TypeBound.createBoundOrDependency(theta, this.superInterfaces[i+ifcOffset], variable);
+ int idx = 0;
+ if (!this.firstBound.isInterface())
+ bounds[idx++] = TypeBound.createBoundOrDependency(theta, this.firstBound, variable);
+ for (int i = 0; i < this.superInterfaces.length; i++)
+ bounds[idx++] = TypeBound.createBoundOrDependency(theta, this.superInterfaces[i], variable);
return bounds;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/TheOriginalJDTParserClass.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/TheOriginalJDTParserClass.java
index 2479ee5..613555c 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/TheOriginalJDTParserClass.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/TheOriginalJDTParserClass.java
@@ -2620,7 +2620,7 @@
}
}
}
- typeDecl.createDefaultConstructor(!this.diet || insideFieldInitializer, true);
+ typeDecl.createDefaultConstructor(!(this.diet && this.dietInt == 0) || insideFieldInitializer, true);
}
}
//always add <clinit> (will be remove at code gen time if empty)
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
index 8d724bc..5e551ad 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DefaultBindingResolver.java
@@ -533,7 +533,7 @@
return null;
}
- class AnnotationIdentityBinding {
+ static class AnnotationIdentityBinding {
org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding internalInstance;
AnnotationIdentityBinding(org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding internalInstance) {
this.internalInstance = internalInstance;
@@ -557,13 +557,9 @@
}
}
Object key = new AnnotationIdentityBinding(internalInstance);
- IAnnotationBinding domInstance =
- (IAnnotationBinding) this.bindingTables.compilerAnnotationBindingsToASTBindings.get(key);
- if (domInstance != null)
- return domInstance;
- domInstance = new AnnotationBinding(internalInstance, this);
- this.bindingTables.compilerAnnotationBindingsToASTBindings.put(key, domInstance);
- return domInstance;
+ IAnnotationBinding newDomInstance = new AnnotationBinding(internalInstance, this);
+ IAnnotationBinding domInstance = (IAnnotationBinding) ((ConcurrentHashMap)this.bindingTables.compilerAnnotationBindingsToASTBindings).putIfAbsent(key, newDomInstance);
+ return domInstance != null ? domInstance : newDomInstance;
}
boolean isResolvedTypeInferredFromExpectedType(MethodInvocation methodInvocation) {
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/imports/ReorderingImportAdder.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/imports/ReorderingImportAdder.java
index adc5e97..3a249d0 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/imports/ReorderingImportAdder.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/imports/ReorderingImportAdder.java
@@ -19,7 +19,8 @@
import java.util.Set;
/**
- * Totally sorts new and existing imports together, discarding the order of existing imports.
+ * Totally sorts new and existing imports together, discarding the order of existing imports
+ * and omitting duplicate entries.
*/
final class ReorderingImportAdder implements ImportAdder {
private final Comparator<ImportName> importComparator;
@@ -30,18 +31,14 @@
@Override
public List<ImportName> addImports(Collection<ImportName> existingImports, Collection<ImportName> importsToAdd) {
- Set<ImportName> existingImportsSet = new HashSet<ImportName>(existingImports);
+ int setCapacity = 2 * (existingImports.size() + importsToAdd.size());
+ Set<ImportName> uniqueImportsWithAdditions = new HashSet<ImportName>(setCapacity);
+ uniqueImportsWithAdditions.addAll(existingImports);
+ uniqueImportsWithAdditions.addAll(importsToAdd);
- List<ImportName> importsWithAdditions = new ArrayList<ImportName>(existingImports.size() + importsToAdd.size());
- importsWithAdditions.addAll(existingImports);
- for (ImportName importToAdd : importsToAdd) {
- if (!existingImportsSet.contains(importToAdd)) {
- importsWithAdditions.add(importToAdd);
- }
- }
+ List<ImportName> sortedImports = new ArrayList<>(uniqueImportsWithAdditions);
+ Collections.sort(sortedImports, this.importComparator);
- Collections.sort(importsWithAdditions, this.importComparator);
-
- return importsWithAdditions;
+ return sortedImports;
}
}
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java
index e31367b..59ba4e0 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/CommentsPreparator.java
@@ -14,10 +14,7 @@
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_BLOCK;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_JAVADOC;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_LINE;
-import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameLBRACE;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameNotAToken;
-import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameRBRACE;
-import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameRPAREN;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameStringLiteral;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameWHITESPACE;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamepackage;
@@ -38,11 +35,13 @@
import org.eclipse.jdt.core.dom.LineComment;
import org.eclipse.jdt.core.dom.MemberRef;
import org.eclipse.jdt.core.dom.MethodRef;
+import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.formatter.CodeFormatter;
import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
+import org.eclipse.jdt.internal.formatter.Token.WrapMode;
import org.eclipse.jdt.internal.formatter.Token.WrapPolicy;
public class CommentsPreparator extends ASTVisitor {
@@ -54,16 +53,17 @@
private final static Pattern HTML_TAG_PATTERN;
private final static Pattern HTML_ATTRIBUTE_PATTERN;
static {
- String formatCodeTags = "(pre)?"; //$NON-NLS-1$
- String separateLineTags = "(dl|hr|nl|p|ul|ol|table|tr)?"; //$NON-NLS-1$
- String breakBeforeTags = "(dd|dt|li|td|th|h1|h2|h3|h4|h5|h6|q)?"; //$NON-NLS-1$
- String breakAfterTags = "(br)?"; //$NON-NLS-1$
- String noFormatTags = "(code|em|tt)?"; //$NON-NLS-1$
- String otherTags = "([^<>&&\\S]+)??"; //$NON-NLS-1$
- String ws = "(?:[ \\t]+|[\\r\\n]+[ \\t]*\\*?)"; // whitespace or line break with optional asterisk //$NON-NLS-1$
- String attribute = "(?:" + ws + "+[^=&&\\S]+" + ws + "*(=)" + ws + "*\"?[^\"]*\"?)"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
- HTML_TAG_PATTERN = Pattern.compile("<(/)?" //$NON-NLS-1$
- + formatCodeTags + separateLineTags + breakBeforeTags + breakAfterTags + noFormatTags + otherTags
+ String formatCodeTags = "(pre)"; //$NON-NLS-1$
+ String separateLineTags = "(dl|hr|nl|p|ul|ol|table|tr)"; //$NON-NLS-1$
+ String breakBeforeTags = "(dd|dt|li|td|th|h1|h2|h3|h4|h5|h6|q)"; //$NON-NLS-1$
+ String breakAfterTags = "(br)"; //$NON-NLS-1$
+ String noFormatTags = "(code|em|tt)"; //$NON-NLS-1$
+ String otherTags = "([^<>&&\\S]++)"; //$NON-NLS-1$
+ String ws = "(?>[ \\t]++|[\\r\\n]++[ \\t]*+\\*?)"; // whitespace or line break with optional asterisk //$NON-NLS-1$
+ String attributeValue = "(?>\"[^\"]*\")|(?>\'[^\']*\')|[^/>\"\'&&\\S]++"; //$NON-NLS-1$
+ String attribute = "(?>" + ws + "+[^=&&\\S]+" + ws + "*(=)" + ws + "*(?>" + attributeValue + "))"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
+ HTML_TAG_PATTERN = Pattern.compile("<(/)?+(?:" //$NON-NLS-1$
+ + formatCodeTags + '|' + separateLineTags + '|' + breakBeforeTags + '|' + breakAfterTags + '|' + noFormatTags + '|' + otherTags + ')'
+ "(" + attribute + "*)" + ws + "*/?>", Pattern.CASE_INSENSITIVE); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
HTML_ATTRIBUTE_PATTERN = Pattern.compile(attribute);
}
@@ -77,17 +77,12 @@
// TODO (frederic) should have another name than 'param' for the following tags
// TODO (frederic) investigate how and why this list was created
private final static List<String> PARAM_TAGS = Arrays.asList(
- "@param", //$NON-NLS-1$
- "@exception", //$NON-NLS-1$
- "@serialField", //$NON-NLS-1$
- "@throws"); //$NON-NLS-1$
+ TagElement.TAG_PARAM,
+ TagElement.TAG_EXCEPTION,
+ TagElement.TAG_SERIALFIELD,
+ TagElement.TAG_THROWS);
- private final static List<String> IMMUTABLE_TAGS = Arrays.asList("@code", "@literal"); //$NON-NLS-1$ //$NON-NLS-2$
-
- private final static int[] NO_INDENT_AFTER_COMMENT = { TokenNameRPAREN, TokenNameLBRACE, TokenNameRBRACE };
- static {
- Arrays.sort(NO_INDENT_AFTER_COMMENT);
- }
+ private final static List<String> IMMUTABLE_TAGS = Arrays.asList(TagElement.TAG_CODE, TagElement.TAG_LITERAL);
private final TokenManager tm;
private final DefaultCodeFormatterOptions options;
@@ -172,7 +167,7 @@
if (policy == null) {
int lineStart = this.tm.getPositionInLine(this.tm.findFirstTokenInLine(commentIndex - 1));
int commentStart = this.tm.getPositionInLine(commentIndex - 1);
- policy = new WrapPolicy(commentStart - lineStart, commentIndex - 1, true);
+ policy = new WrapPolicy(WrapMode.WHERE_NECESSARY, commentIndex - 1, commentStart - lineStart);
}
commentToken.setWrapPolicy(policy);
this.lastLineComment = commentToken;
@@ -187,7 +182,8 @@
if (isContinuation) {
Token first = structure.get(0);
first.breakBefore();
- first.setWrapPolicy(new WrapPolicy(this.lastLineCommentPosition, commentIndex - 1, false));
+ first.setWrapPolicy(
+ new WrapPolicy(WrapMode.WHERE_NECESSARY, commentIndex - 1, this.lastLineCommentPosition));
// merge previous and current line comment
Token previous = this.lastLineComment;
@@ -216,11 +212,13 @@
structure.get(0).clearSpaceBefore();
Token previous = this.tm.get(commentIndex - 1);
+ previous.clearSpaceAfter();
if (previous.originalEnd + 1 >= commentToken.originalStart)
return;
if (structure == null || structure.isEmpty()) {
structure = new ArrayList<Token>();
structure.add(new Token(previous.originalEnd + 1, commentToken.originalEnd, TokenNameCOMMENT_LINE));
+ commentToken.setInternalStructure(structure);
} else {
structure.add(0, new Token(previous.originalEnd + 1, commentToken.originalStart - 1,
TokenNameWHITESPACE));
@@ -418,17 +416,6 @@
next = next2;
}
- if (previous != null && previous.getLineBreaksAfter() == 0
- && next != null && next.getLineBreaksBefore() == 0
- && Arrays.binarySearch(NO_INDENT_AFTER_COMMENT, next.tokenType) < 0) {
- int policyIndent = (commentToken.getIndent() - previous.getIndent());
- WrapPolicy wrapPolicy = new WrapPolicy(policyIndent, commentIndex - 1, true);
- if (this.tm.countLineBreaksBetween(previous, commentToken) == 1)
- commentToken.setWrapPolicy(wrapPolicy);
- if (this.tm.countLineBreaksBetween(commentToken, next) == 1)
- next.setWrapPolicy(wrapPolicy);
- }
-
if (existingBreaksBefore < existingBreaksAfter && previous != null) {
commentToken.putLineBreaksAfter(previous.getLineBreaksAfter());
previous.clearLineBreaksAfter();
@@ -591,6 +578,7 @@
}
Token startTokeen = this.ctm.get(startIndex);
+ if (startIndex > 1)
startTokeen.breakBefore();
int firstTagIndex;
if (this.firstTagToken == null || (firstTagIndex = this.ctm.indexOf(this.firstTagToken)) < 0
@@ -672,6 +660,11 @@
handleFormatCodeTag(startPos, endPos, isOpeningTag);
}
if (this.options.comment_format_html) {
+ if (TagElement.TAG_PARAM.equals(node.getTagName())
+ && this.ctm.findIndex(startPos, -1, false) == 1 + this.ctm.firstIndexIn(node, -1)) {
+ continue; // it's a generic class parameter name, not an HTML tag
+ }
+
if (matcher.start(3) < matcher.end(3)) {
handleSeparateLineTag(startPos, endPos);
} else if (matcher.start(4) < matcher.end(4)) {
@@ -697,6 +690,12 @@
return true;
}
+ @Override
+ public boolean visit(QualifiedName node) {
+ handleReference(node);
+ return false;
+ }
+
private void handleReference(ASTNode node) {
ASTNode parent = node.getParent();
if ((parent instanceof TagElement) && ((TagElement) parent).isNested()) {
@@ -742,12 +741,12 @@
int firstPartIndex = tokenStartingAt(start);
int lastPartIndex = tokenEndingAt(end);
Token firstPartToken = this.ctm.get(firstPartIndex);
+ firstPartToken.setWrapPolicy(null);
if (isOpeningTag) {
firstPartToken.breakBefore();
this.ctm.get(lastPartIndex + 1).clearSpaceBefore();
} else {
firstPartToken.clearSpaceBefore();
- firstPartToken.setWrapPolicy(null);
}
}
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatter.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatter.java
index f7a3580..d971284 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatter.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatter.java
@@ -74,6 +74,7 @@
private String sourceString;
private char[] sourceArray;
+ private IRegion[] formatRegions;
private ASTNode astRoot;
private List<Token> tokens = new ArrayList<Token>();
@@ -146,11 +147,12 @@
if (!regionsSatisfiesPreconditions(regions, source.length())) {
throw new IllegalArgumentException();
}
+ this.formatRegions = regions;
updateWorkingOptions(indentationLevel, lineSeparator, kind);
if ((kind & K_COMMENTS_MASK) != 0)
- return formatComments(source, kind & K_COMMENTS_MASK, regions);
+ return formatComments(source, kind & K_COMMENTS_MASK);
if (prepareFormattedCode(source, kind) == null)
return this.tokens.isEmpty() ? new MultiTextEdit() : null;
@@ -202,15 +204,17 @@
private void findHeader() {
if (this.astRoot instanceof CompilationUnit) {
- List<TypeDeclaration> types = ((CompilationUnit) this.astRoot).types();
- if (!types.isEmpty()) {
- int headerEndIndex = this.tokenManager.firstIndexIn(types.get(0), -1);
+ CompilationUnit unit = (CompilationUnit) this.astRoot;
+ List<TypeDeclaration> types = unit.types();
+ ASTNode firstElement = types.isEmpty() ? unit.getPackage() : types.get(0);
+ if (firstElement != null) {
+ int headerEndIndex = this.tokenManager.firstIndexIn(firstElement, -1);
this.tokenManager.setHeaderEndIndex(headerEndIndex);
}
}
}
- private TextEdit formatComments(String source, int kind, IRegion[] regions) {
+ private TextEdit formatComments(String source, int kind) {
MultiTextEdit result = new MultiTextEdit();
if (!init(source))
return result;
@@ -264,7 +268,8 @@
this.tokenManager.applyFormatOff();
- TextEditsBuilder resultBuilder = new TextEditsBuilder(source, regions, this.tokenManager, this.workingOptions);
+ TextEditsBuilder resultBuilder = new TextEditsBuilder(source, this.formatRegions, this.tokenManager,
+ this.workingOptions);
resultBuilder.setAlignChar(DefaultCodeFormatterOptions.SPACE);
for (Token token : this.tokens) {
List<Token> structure = token.getInternalStructure();
@@ -282,6 +287,7 @@
ASTParser parser = ASTParser.newParser(AST.JLS8);
Map<String, String> parserOptions = JavaCore.getOptions();
parserOptions.put(CompilerOptions.OPTION_Source, this.sourceLevel);
+ parserOptions.put(CompilerOptions.OPTION_DocCommentSupport, CompilerOptions.ENABLED);
parser.setCompilerOptions(parserOptions);
switch (kind & K_MASK) {
@@ -370,7 +376,7 @@
private void prepareWraps(int kind) {
WrapPreparator wrapPreparator = new WrapPreparator(this.tokenManager, this.workingOptions, kind);
this.astRoot.accept(wrapPreparator);
- wrapPreparator.finishUp(this.astRoot);
+ wrapPreparator.finishUp(this.astRoot, this.formatRegions);
}
/**
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatterOptions.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatterOptions.java
index f64a154..58ecff8 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatterOptions.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/DefaultCodeFormatterOptions.java
@@ -710,7 +710,7 @@
options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, DefaultCodeFormatterConstants.MIXED);
break;
}
- options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, Integer.toString(this.tab_char == MIXED ? this.tab_size : this.indentation_size)); // reverse values swapping performed by IndentationTabPage
+ options.put(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, Integer.toString(this.tab_char == SPACE ? this.indentation_size : this.tab_size)); // reverse values swapping performed by IndentationTabPage
options.put(DefaultCodeFormatterConstants.FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS, this.use_tabs_only_for_leading_indentations ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
options.put(DefaultCodeFormatterConstants.FORMATTER_WRAP_BEFORE_BINARY_OPERATOR, this.wrap_before_binary_operator ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
options.put(DefaultCodeFormatterConstants.FORMATTER_WRAP_BEFORE_OR_OPERATOR_MULTICATCH, this.wrap_before_or_operator_multicatch ? DefaultCodeFormatterConstants.TRUE : DefaultCodeFormatterConstants.FALSE);
@@ -1326,7 +1326,7 @@
// reverse values swapping performed by IndentationTabPage
if (DefaultCodeFormatterConstants.MIXED.equals(settings.get(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
this.indentation_size = indentationSize;
- else
+ else if (JavaCore.SPACE.equals(settings.get(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
this.tab_size = indentationSize;
}
final Object insertNewLineAfterOpeningBraceInArrayInitializerOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_INSERT_NEW_LINE_AFTER_OPENING_BRACE_IN_ARRAY_INITIALIZER);
@@ -2098,9 +2098,9 @@
// keep default
}
// reverse values swapping performed by IndentationTabPage
- if (DefaultCodeFormatterConstants.MIXED.equals(settings.get(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
+ if (!JavaCore.SPACE.equals(settings.get(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
this.tab_size = tabSize;
- else
+ if (!DefaultCodeFormatterConstants.MIXED.equals(settings.get(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR)))
this.indentation_size = tabSize;
}
final Object useTabsOnlyForLeadingIndentationsOption = settings.get(DefaultCodeFormatterConstants.FORMATTER_USE_TABS_ONLY_FOR_LEADING_INDENTATIONS);
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java
index 32640ec..6cbfa89 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/LineBreaksPreparator.java
@@ -18,6 +18,7 @@
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameLBRACE;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameRBRACE;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameSEMICOLON;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_JAVADOC;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameelse;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamefinally;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamepackage;
@@ -38,6 +39,7 @@
import org.eclipse.jdt.core.dom.BreakStatement;
import org.eclipse.jdt.core.dom.CatchClause;
import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.ContinueStatement;
import org.eclipse.jdt.core.dom.DoStatement;
import org.eclipse.jdt.core.dom.EmptyStatement;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
@@ -97,12 +99,10 @@
List<AnnotationTypeDeclaration> types = node.types();
if (!types.isEmpty()) {
if (!imports.isEmpty())
- this.tm.firstTokenIn(types.get(0), -1).putLineBreaksBefore(this.options.blank_lines_after_imports + 1);
- for (int i = 1; i < types.size(); i++) {
- this.tm.firstTokenIn(types.get(i), -1).putLineBreaksBefore(
- this.options.blank_lines_between_type_declarations + 1);
+ putBlankLinesBefore(types.get(0), this.options.blank_lines_after_imports);
+ for (int i = 1; i < types.size(); i++)
+ putBlankLinesBefore(types.get(i), this.options.blank_lines_between_type_declarations);
}
- }
return true;
}
@@ -146,21 +146,22 @@
BodyDeclaration previous = null;
for (BodyDeclaration bodyDeclaration : bodyDeclarations) {
if (previous == null) {
- this.tm.firstTokenIn(bodyDeclaration, -1).putLineBreaksBefore(
- this.options.blank_lines_before_first_class_body_declaration + 1);
+ putBlankLinesBefore(bodyDeclaration, this.options.blank_lines_before_first_class_body_declaration);
} else {
- int blankLines;
- if (bodyDeclaration instanceof FieldDeclaration)
+ int blankLines = 0;
+ if (bodyDeclaration instanceof FieldDeclaration) {
blankLines = this.options.blank_lines_before_field;
- else if (bodyDeclaration instanceof AbstractTypeDeclaration)
+ } else if (bodyDeclaration instanceof AbstractTypeDeclaration) {
blankLines = this.options.blank_lines_before_member_type;
- else
+ } else if (bodyDeclaration instanceof MethodDeclaration
+ || bodyDeclaration instanceof AnnotationTypeMemberDeclaration) {
blankLines = this.options.blank_lines_before_method;
+ }
if (!sameChunk(previous, bodyDeclaration))
blankLines = Math.max(blankLines, this.options.blank_lines_before_new_chunk);
- this.tm.firstTokenIn(bodyDeclaration, -1).putLineBreaksBefore(blankLines + 1);
+ putBlankLinesBefore(bodyDeclaration, blankLines);
}
previous = bodyDeclaration;
}
@@ -171,12 +172,19 @@
return true;
if (bd1 instanceof AbstractTypeDeclaration && bd2 instanceof AbstractTypeDeclaration)
return true;
- if ((bd1 instanceof MethodDeclaration || bd1 instanceof Initializer)
- && (bd2 instanceof MethodDeclaration || bd2 instanceof Initializer))
+ if ((bd1 instanceof FieldDeclaration || bd1 instanceof Initializer)
+ && (bd2 instanceof FieldDeclaration || bd2 instanceof Initializer))
return true;
return false;
}
+ private void putBlankLinesBefore(ASTNode node, int linesCount) {
+ int index = this.tm.firstIndexIn(node, -1);
+ while (index > 0 && this.tm.get(index - 1).tokenType == TokenNameCOMMENT_JAVADOC)
+ index--;
+ this.tm.get(index).putLineBreaksBefore(linesCount + 1);
+ }
+
@Override
public boolean visit(EnumDeclaration node) {
handleBracedCode(node, node.getName(), this.options.brace_position_for_enum_declaration,
@@ -185,9 +193,11 @@
handleBodyDeclarations(node.bodyDeclarations());
List<EnumConstantDeclaration> enumConstants = node.enumConstants();
- for (int i = 0; i < enumConstants.size() - 1; i++) {
+ for (int i = 0; i < enumConstants.size(); i++) {
EnumConstantDeclaration declaration = enumConstants.get(i);
- if (declaration.getAnonymousClassDeclaration() != null)
+ if (declaration.getJavadoc() != null)
+ this.tm.firstTokenIn(declaration, TokenNameCOMMENT_JAVADOC).breakBefore();
+ if (declaration.getAnonymousClassDeclaration() != null && i < enumConstants.size() - 1)
this.tm.firstTokenAfter(declaration, TokenNameCOMMA).breakAfter();
}
@@ -239,11 +249,16 @@
@Override
public boolean visit(MethodDeclaration node) {
+ this.declarationModifierVisited = false;
+
+ if (node.getBody() == null)
+ return true;
+
if (node.isConstructor()) {
handleBracedCode(node.getBody(), null, this.options.brace_position_for_constructor_declaration,
this.options.indent_statements_compare_to_body,
this.options.insert_new_line_in_empty_method_body);
- } else if (node.getBody() != null) {
+ } else {
handleBracedCode(node.getBody(), null, this.options.brace_position_for_method_declaration,
this.options.indent_statements_compare_to_body,
this.options.insert_new_line_in_empty_method_body);
@@ -251,7 +266,6 @@
if (openBrace.getLineBreaksAfter() > 0) // if not, these are empty braces
openBrace.putLineBreaksAfter(this.options.blank_lines_at_beginning_of_method_body + 1);
}
- this.declarationModifierVisited = false;
return true;
}
@@ -297,6 +311,10 @@
if (this.options.indent_switchstatements_compare_to_cases) {
int nonBreakStatementEnd = -1;
for (Statement statement : statements) {
+ boolean isBreaking = statement instanceof BreakStatement || statement instanceof ReturnStatement
+ || statement instanceof ContinueStatement || statement instanceof Block;
+ if (isBreaking)
+ addEmptyLineTokenAfter(this.tm.lastIndexIn(statement, -1));
if (statement instanceof SwitchCase) {
if (nonBreakStatementEnd >= 0) {
// indent only comments between previous and current statement
@@ -306,8 +324,7 @@
} else if (!(statement instanceof BreakStatement || statement instanceof Block)) {
indent(statement);
}
- nonBreakStatementEnd = (statement instanceof BreakStatement || statement instanceof ReturnStatement)
- ? -1 : this.tm.lastIndexIn(statement, -1);
+ nonBreakStatementEnd = isBreaking ? -1 : this.tm.lastIndexIn(statement, -1);
}
if (nonBreakStatementEnd >= 0) {
// indent comments between last statement and closing brace
@@ -354,28 +371,34 @@
@Override
public boolean visit(ArrayInitializer node) {
int openBraceIndex = this.tm.firstIndexIn(node, TokenNameLBRACE);
- Token afterOpenBraceToken = this.tm.get(openBraceIndex + 1);
- boolean isEmpty = afterOpenBraceToken.tokenType == TokenNameRBRACE;
- if (isEmpty && this.options.keep_empty_array_initializer_on_one_line)
- return true;
+ int closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
+
+ boolean isEmpty = openBraceIndex + 1 == closeBraceIndex;
+ if (isEmpty) {
+ addEmptyLineTokenAfter(openBraceIndex);
+ closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
+ }
Token openBraceToken = this.tm.get(openBraceIndex);
- int closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
+ Token closeBraceToken = this.tm.get(closeBraceIndex);
+
+ if (!(node.getParent() instanceof ArrayInitializer)) {
+ Token afterOpenBraceToken = this.tm.get(openBraceIndex + 1);
+ for (int i = 0; i < this.options.continuation_indentation_for_array_initializer; i++) {
+ afterOpenBraceToken.indent();
+ closeBraceToken.unindent();
+ }
+ }
+
+ if (!isEmpty || !this.options.keep_empty_array_initializer_on_one_line)
handleBracePosition(openBraceToken, closeBraceIndex, this.options.brace_position_for_array_initializer);
if (!isEmpty) {
- Token closeBraceToken = this.tm.get(closeBraceIndex);
if (this.options.insert_new_line_after_opening_brace_in_array_initializer)
openBraceToken.breakAfter();
if (this.options.insert_new_line_before_closing_brace_in_array_initializer)
closeBraceToken.breakBefore();
- if (!(node.getParent() instanceof ArrayInitializer)) {
- for (int i = 0; i < this.options.continuation_indentation_for_array_initializer; i++) {
- afterOpenBraceToken.indent();
- closeBraceToken.unindent();
}
- }
- }
return true;
}
@@ -449,9 +472,11 @@
breakAfter = this.options.insert_new_line_after_annotation_on_type;
} else if (parentNode instanceof FieldDeclaration) {
breakAfter = this.options.insert_new_line_after_annotation_on_field;
- } else if (parentNode instanceof MethodDeclaration
- || parentNode instanceof AnnotationTypeMemberDeclaration) {
+ } else if (parentNode instanceof MethodDeclaration) {
breakAfter = this.options.insert_new_line_after_annotation_on_method;
+ } else if (parentNode instanceof AnnotationTypeMemberDeclaration) {
+ breakAfter = this.options.insert_new_line_after_annotation_on_method
+ && ((AnnotationTypeMemberDeclaration) parentNode).getDefault() != node;
} else if (parentNode instanceof VariableDeclarationStatement
|| parentNode instanceof VariableDeclarationExpression) {
breakAfter = this.options.insert_new_line_after_annotation_on_local_variable;
@@ -483,12 +508,15 @@
}
private void handleLoopBody(Statement body) {
- if (!(body instanceof Block)
- && !(body instanceof EmptyStatement && !this.options.put_empty_statement_on_new_line)) {
+ if (body instanceof Block)
+ return;
+ if (body instanceof EmptyStatement && !this.options.put_empty_statement_on_new_line
+ && !(body.getParent() instanceof IfStatement))
+ return;
breakLineBefore(body);
+ addEmptyLineTokenAfter(this.tm.lastIndexIn(body, -1));
indent(body);
}
- }
@Override
public boolean visit(IfStatement node) {
@@ -498,21 +526,16 @@
if (this.options.insert_new_line_before_else_in_if_statement || !(thenNode instanceof Block))
this.tm.firstTokenBefore(elseNode, TokenNameelse).breakBefore();
- boolean keepElseOnSameLine = (elseNode instanceof Block)
- || (this.options.keep_else_statement_on_same_line)
+ boolean keepElseOnSameLine = (this.options.keep_else_statement_on_same_line)
|| (this.options.compact_else_if && (elseNode instanceof IfStatement));
- if (!keepElseOnSameLine) {
- breakLineBefore(elseNode);
- indent(elseNode);
+ if (!keepElseOnSameLine)
+ handleLoopBody(elseNode);
}
- }
boolean keepThenOnSameLine = this.options.keep_then_statement_on_same_line
|| (this.options.keep_simple_if_on_one_line && elseNode == null);
- if (!keepThenOnSameLine && !(thenNode instanceof Block)) {
- breakLineBefore(thenNode);
- indent(thenNode);
- }
+ if (!keepThenOnSameLine)
+ handleLoopBody(thenNode);
return true;
}
@@ -543,6 +566,7 @@
: this.tm.firstIndexAfter(nodeBeforeOpenBrace, TokenNameLBRACE);
int closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
Token openBraceToken = this.tm.get(openBraceIndex);
+ Token closeBraceToken = this.tm.get(closeBraceIndex);
handleBracePosition(openBraceToken, closeBraceIndex, bracePosition);
boolean isEmpty = true;
@@ -552,13 +576,16 @@
break;
}
}
+
+ addEmptyLineTokenAfter(openBraceIndex);
+
if (!isEmpty || newLineInEmpty) {
openBraceToken.breakAfter();
- this.tm.get(closeBraceIndex).breakBefore();
+ closeBraceToken.breakBefore();
}
if (indentBody) {
this.tm.get(openBraceIndex + 1).indent();
- this.tm.get(closeBraceIndex).unindent();
+ closeBraceToken.unindent();
}
}
@@ -575,6 +602,32 @@
}
}
+ private void addEmptyLineTokenAfter(int tokenIndex) {
+ if (tokenIndex + 1 >= this.tm.size())
+ return;
+ Token token = this.tm.get(tokenIndex);
+ Token next = this.tm.get(tokenIndex + 1);
+ if (this.tm.countLineBreaksBetween(token, next) < 2 || !this.options.indent_empty_lines)
+ return;
+
+ // find a line break and make a token out of it
+ for (int i = token.originalEnd + 1; i < next.originalStart; i++) {
+ char c = this.tm.charAt(i);
+ char c2 = this.tm.charAt(i + 1);
+ int lineBreakStart = (c == '\r' || c == '\n') ? i : -1;
+ int lineBreakEnd = ((c2 == '\r' || c2 == '\n') && c2 != c) ? i + 1 : lineBreakStart;
+ if (lineBreakStart >= 0) {
+ Token emptyLineToken = new Token(lineBreakStart, lineBreakEnd, Token.TokenNameEMPTY_LINE);
+ emptyLineToken.breakBefore();
+ emptyLineToken.breakAfter();
+ emptyLineToken.setToEscape(true); // force text builder to use toString()
+ this.tm.insert(tokenIndex + 1, emptyLineToken);
+ return;
+ }
+ }
+ assert false;
+ }
+
private void indent(ASTNode node) {
int startIndex = this.tm.firstIndexIn(node, -1);
while (startIndex > 0 && this.tm.get(startIndex - 1).isComment())
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java
index 63a49a4..bfc18dc 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/SpacePreparator.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2014, 2015 Mateusz Matela and others.
+ * Copyright (c) 2014, 2016 Mateusz Matela and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -46,6 +46,7 @@
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.ForStatement;
import org.eclipse.jdt.core.dom.IfStatement;
+import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.InstanceofExpression;
import org.eclipse.jdt.core.dom.IntersectionType;
@@ -56,6 +57,7 @@
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.NormalAnnotation;
+import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.ParameterizedType;
import org.eclipse.jdt.core.dom.ParenthesizedExpression;
import org.eclipse.jdt.core.dom.PostfixExpression;
@@ -102,6 +104,18 @@
}
@Override
+ public boolean visit(PackageDeclaration node) {
+ handleSemicolon(node);
+ return true;
+ }
+
+ @Override
+ public boolean visit(ImportDeclaration node) {
+ handleSemicolon(node);
+ return true;
+ }
+
+ @Override
public boolean visit(TypeDeclaration node) {
if (node.getName().getStartPosition() == -1)
return true; // this is a fake type created by parsing in class body mode
@@ -111,6 +125,11 @@
List<TypeParameter> typeParameters = node.typeParameters();
handleTypeParameters(typeParameters);
+ if (!node.isInterface() && !node.superInterfaceTypes().isEmpty()) {
+ // fix for: class A<E> extends ArrayList<String>implements Callable<String>
+ handleToken(node.getName(), TokenNameimplements, true, false);
+ }
+
handleToken(node.getName(), TokenNameLBRACE,
this.options.insert_space_before_opening_brace_in_type_declaration, false);
handleCommas(node.superInterfaceTypes(), this.options.insert_space_before_comma_in_superinterfaces,
@@ -122,6 +141,8 @@
public boolean visit(EnumDeclaration node) {
handleToken(node.getName(), TokenNameLBRACE,
this.options.insert_space_before_opening_brace_in_enum_declaration, false);
+ handleCommas(node.superInterfaceTypes(), this.options.insert_space_before_comma_in_superinterfaces,
+ this.options.insert_space_after_comma_in_superinterfaces);
handleCommas(node.enumConstants(), this.options.insert_space_before_comma_in_enum_declarations,
this.options.insert_space_after_comma_in_enum_declarations);
return true;
@@ -186,9 +207,14 @@
} else {
handleToken(node.getName(), TokenNameLPAREN, spaceBeforeOpenParen, spaceAfterOpenParen);
- if (node.isConstructor() ? this.options.insert_space_before_closing_paren_in_constructor_declaration
- : this.options.insert_space_before_closing_paren_in_method_declaration)
- handleToken(node.getName(), TokenNameRPAREN, true, false);
+ boolean spaceBeforeCloseParen = node.isConstructor()
+ ? this.options.insert_space_before_closing_paren_in_constructor_declaration
+ : this.options.insert_space_before_closing_paren_in_method_declaration;
+ if (spaceBeforeCloseParen) {
+ List<SingleVariableDeclaration> params = node.parameters();
+ ASTNode beforeBrace = params.isEmpty() ? node.getName() : params.get(params.size() - 1);
+ handleTokenAfter(beforeBrace, TokenNameRPAREN, true, false);
+ }
}
if ((node.isConstructor() ? this.options.insert_space_before_opening_brace_in_constructor_declaration
@@ -222,6 +248,8 @@
handleTokenBefore(typeParameters.get(0), TokenNameLESS, true, false);
handleTokenAfter(typeParameters.get(typeParameters.size() - 1), TokenNameGREATER, false, true);
}
+
+ handleSemicolon(node);
return true;
}
@@ -243,6 +271,7 @@
handleToken((ASTNode) node.fragments().get(0), TokenNameIdentifier, true, false);
handleCommas(node.fragments(), this.options.insert_space_before_comma_in_multiple_field_declarations,
this.options.insert_space_after_comma_in_multiple_field_declarations);
+ handleSemicolon(node);
return true;
}
@@ -287,6 +316,7 @@
this.options.insert_space_before_closing_paren_in_switch, false);
handleTokenAfter(node.getExpression(), TokenNameLBRACE,
this.options.insert_space_before_opening_brace_in_switch, false);
+ handleSemicolon(node.statements());
return true;
}
@@ -369,6 +399,7 @@
@Override
public boolean visit(AssertStatement node) {
+ this.tm.firstTokenIn(node, TokenNameassert).spaceAfter();
if (node.getMessage() != null) {
handleTokenBefore(node.getMessage(), TokenNameCOLON, this.options.insert_space_before_colon_in_assert,
this.options.insert_space_after_colon_in_assert);
@@ -416,6 +447,7 @@
@Override
public boolean visit(AnnotationTypeMemberDeclaration node) {
+ handleToken(node.getName(), TokenNameIdentifier, true, false);
handleToken(node.getName(), TokenNameLPAREN,
this.options.insert_space_before_opening_paren_in_annotation_type_member_declaration, false);
handleEmptyParens(node.getName(),
@@ -457,11 +489,16 @@
if (handleParenthesis) {
handleToken(node, TokenNameLPAREN, this.options.insert_space_before_opening_paren_in_annotation,
this.options.insert_space_after_opening_paren_in_annotation);
- handleToken(node, TokenNameRPAREN, this.options.insert_space_before_closing_paren_in_annotation, false);
+ if (this.options.insert_space_before_closing_paren_in_annotation)
+ this.tm.lastTokenIn(node, TokenNameRPAREN).spaceBefore();
}
ASTNode parent = node.getParent();
- if (!(parent instanceof Annotation) && !(parent instanceof ArrayInitializer))
+ boolean skipSpaceAfter = parent instanceof Annotation || parent instanceof MemberValuePair
+ || (parent instanceof AnnotationTypeMemberDeclaration
+ && ((AnnotationTypeMemberDeclaration) parent).getDefault() == node)
+ || parent instanceof ArrayInitializer;
+ if (!skipSpaceAfter)
this.tm.lastTokenIn(node, -1).spaceAfter();
}
@@ -479,7 +516,7 @@
this.options.insert_space_before_opening_paren_in_method_declaration,
this.options.insert_space_after_opening_paren_in_method_declaration);
- handleToken(node, TokenNameRPAREN,
+ handleTokenBefore(node.getBody(), TokenNameRPAREN,
this.options.insert_space_before_closing_paren_in_method_declaration, false);
}
handleCommas(parameters, this.options.insert_space_before_comma_in_method_declaration_parameters,
@@ -490,20 +527,20 @@
@Override
public boolean visit(Block node) {
- if (node.getParent().getLength() == 0)
+ handleSemicolon(node.statements());
+
+ ASTNode parent = node.getParent();
+ if (parent.getLength() == 0)
return true; // this is a fake block created by parsing in statements mode
- if (node.getParent() instanceof MethodDeclaration)
+ if (parent instanceof MethodDeclaration)
return true; // spaces handled in #visit(MethodDeclaration)
handleToken(node, TokenNameLBRACE, this.options.insert_space_before_opening_brace_in_block, false);
- if (this.options.insert_space_after_closing_brace_in_block) {
+ if (this.options.insert_space_after_closing_brace_in_block
+ && (parent instanceof Statement || parent instanceof CatchClause)) {
int closeBraceIndex = this.tm.lastIndexIn(node, TokenNameRBRACE);
- if (closeBraceIndex + 1 < this.tm.size()) {
- int nextToken = this.tm.get(closeBraceIndex + 1).tokenType;
- if (nextToken != TokenNameSEMICOLON && nextToken != TokenNameRPAREN)
this.tm.get(closeBraceIndex).spaceAfter();
}
- }
return true;
}
@@ -511,14 +548,19 @@
public boolean visit(IfStatement node) {
handleToken(node, TokenNameLPAREN, this.options.insert_space_before_opening_paren_in_if,
this.options.insert_space_after_opening_paren_in_if);
- handleTokenBefore(node.getThenStatement(), TokenNameRPAREN,
- this.options.insert_space_before_closing_paren_in_if, true);
Statement thenStatement = node.getThenStatement();
- if (thenStatement instanceof Block && this.tm.isGuardClause((Block) node.getThenStatement())) {
+ int closingParenIndex = this.tm.firstIndexBefore(thenStatement, TokenNameRPAREN);
+ handleToken(this.tm.get(closingParenIndex), this.options.insert_space_before_closing_paren_in_if,
+ /* space before then statement may be needed if it will stay on the same line */
+ !(thenStatement instanceof Block) && !this.tm.get(closingParenIndex + 1).isComment());
+
+ if (thenStatement instanceof Block && this.tm.isGuardClause((Block) thenStatement)) {
handleToken(thenStatement, TokenNameLBRACE, false, true);
this.tm.lastTokenIn(node, TokenNameRBRACE).spaceBefore();
}
+
+ handleSemicolon(thenStatement);
return true;
}
@@ -588,7 +630,7 @@
@Override
public boolean visit(ClassInstanceCreation node) {
- handleInvocation(node, node.getType(), node.typeArguments());
+ handleInvocation(node, node.getType(), node.typeArguments(), node.getAnonymousClassDeclaration());
handleCommas(node.arguments(), this.options.insert_space_before_comma_in_allocation_expression,
this.options.insert_space_after_comma_in_allocation_expression);
return true;
@@ -613,6 +655,11 @@
}
private void handleInvocation(ASTNode invocationNode, ASTNode nodeBeforeOpeningParen, List<Type> typeArguments) {
+ handleInvocation(invocationNode, nodeBeforeOpeningParen, typeArguments, null);
+ }
+
+ private void handleInvocation(ASTNode invocationNode, ASTNode nodeBeforeOpeningParen, List<Type> typeArguments,
+ ASTNode nodeAfterClosingParen) {
if (handleEmptyParens(nodeBeforeOpeningParen,
this.options.insert_space_between_empty_parens_in_method_invocation)) {
handleToken(nodeBeforeOpeningParen, TokenNameLPAREN,
@@ -622,7 +669,10 @@
this.options.insert_space_before_opening_paren_in_method_invocation,
this.options.insert_space_after_opening_paren_in_method_invocation);
if (this.options.insert_space_before_closing_paren_in_method_invocation) {
- this.tm.lastTokenIn(invocationNode, TokenNameRPAREN).spaceBefore();
+ Token closingParen = nodeAfterClosingParen == null
+ ? this.tm.lastTokenIn(invocationNode, TokenNameRPAREN)
+ : this.tm.firstTokenBefore(nodeAfterClosingParen, TokenNameRPAREN);
+ closingParen.spaceBefore();
}
}
@@ -808,14 +858,11 @@
@Override
public boolean visit(ParameterizedType node) {
+ List<Type> typeArguments = node.typeArguments();
+ if (!typeArguments.isEmpty()) {
handleTokenAfter(node.getType(), TokenNameLESS,
this.options.insert_space_before_opening_angle_bracket_in_parameterized_type_reference,
this.options.insert_space_after_opening_angle_bracket_in_parameterized_type_reference);
- List<Type> typeArguments = node.typeArguments();
- if (typeArguments.isEmpty()) {
- handleTokenAfter(node.getType(), TokenNameGREATER,
- this.options.insert_space_before_closing_angle_bracket_in_parameterized_type_reference, false);
- } else {
handleTokenAfter(typeArguments.get(typeArguments.size() - 1), TokenNameGREATER,
this.options.insert_space_before_closing_angle_bracket_in_parameterized_type_reference, false);
handleCommas(node.typeArguments(),
@@ -914,6 +961,7 @@
private void handleToken(ASTNode node, int tokenType, boolean spaceBefore, boolean spaceAfter) {
if (spaceBefore || spaceAfter) {
Token token = this.tm.get(this.tm.findIndex(node.getStartPosition(), tokenType, true));
+ // ^not the same as "firstTokenIn(node, tokenType)" - do not assert the token is inside the node
handleToken(token, spaceBefore, spaceAfter);
}
}
@@ -973,6 +1021,21 @@
return false;
}
+ private void handleSemicolon(ASTNode node) {
+ if (this.options.insert_space_before_semicolon) {
+ Token lastToken = this.tm.lastTokenIn(node, -1);
+ if (lastToken.tokenType == TokenNameSEMICOLON)
+ lastToken.spaceBefore();
+ }
+ }
+
+ private void handleSemicolon(List<ASTNode> nodes) {
+ if (this.options.insert_space_before_semicolon) {
+ for (ASTNode node : nodes)
+ handleSemicolon(node);
+ }
+ }
+
public void finishUp() {
this.tm.traverse(0, new TokenTraverser() {
boolean isPreviousJIDP = false;
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java
index f1b92e1..37bbe6e 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TextEditsBuilder.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2014, 2015 Mateusz Matela and others.
+ * Copyright (c) 2014, 2016 Mateusz Matela and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -22,6 +22,7 @@
import java.util.List;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
+import org.eclipse.jdt.internal.formatter.Token.WrapMode;
import org.eclipse.jdt.internal.formatter.Token.WrapPolicy;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
@@ -152,8 +153,16 @@
this.stringLiteralsInLine.clear();
if (getLineBreaksBefore() > 1) {
Token indentToken = null;
- if (this.options.indent_empty_lines && token.tokenType != TokenNameNotAToken)
- indentToken = token.getIndent() > getPrevious().getIndent() ? token : getPrevious();
+ if (this.options.indent_empty_lines && token.tokenType != TokenNameNotAToken) {
+ if (index == 0) {
+ indentToken = token;
+ } else {
+ boolean isForced = token.getWrapPolicy() != null
+ && token.getWrapPolicy().wrapMode == WrapMode.FORCED;
+ Token previous = this.tm.get(this.tm.findFirstTokenInLine(index - 1, true, !isForced));
+ indentToken = (token.getIndent() > previous.getIndent()) ? token : previous;
+ }
+ }
for (int i = 1; i < getLineBreaksBefore(); i++) {
bufferLineSeparator(token, true);
if (indentToken != null)
@@ -222,15 +231,24 @@
int wrapRootIndent = indent;
if (index == -1) { // this means we print a line separator in a multi-line comment
TokenManager tm2 = this.parent.tm;
- wrapRootIndent = tm2.get(tm2.findFirstTokenInLine(this.parentTokenIndex, true)).getIndent();
+ wrapRootIndent = tm2.get(tm2.findFirstTokenInLine(this.parentTokenIndex, true, true)).getIndent();
} else if (wrapPolicy != null) {
- wrapRootIndent = this.tm.get(this.tm.findFirstTokenInLine(index, true)).getIndent();
+ wrapRootIndent = this.tm.get(this.tm.findFirstTokenInLine(index, true, true)).getIndent();
}
additionalSpaces = indent - wrapRootIndent;
indent = wrapRootIndent;
- if (wrapPolicy != null && wrapPolicy.isForced) {
- int extraIndent = wrapPolicy.extraIndent;
+ if (wrapPolicy != null && wrapPolicy.wrapMode == WrapMode.FORCED) {
+ int parentIndex = wrapPolicy.wrapParentIndex;
+ int parentAlign = 0;
+ int lineStart = this.tm.findFirstTokenInLine(parentIndex);
+ for (int i = parentIndex; i >= lineStart; i--) {
+ parentAlign = this.tm.get(i).getAlign();
+ if (parentAlign > 0)
+ break;
+ }
+
+ int extraIndent = parentAlign == 0 ? wrapPolicy.extraIndent : (token.getIndent() - parentAlign);
additionalSpaces -= extraIndent;
indent += extraIndent;
}
@@ -316,29 +334,43 @@
String buffered = this.buffer.toString();
boolean sourceMatch = this.source.startsWith(buffered, this.counter)
&& this.counter + buffered.length() == currentPosition;
- if (!sourceMatch && checkRegions(this.counter, currentPosition)) {
- TextEdit edit = getReplaceEdit(this.counter, currentPosition, buffered);
- this.edits.add(edit);
+ while (!sourceMatch && this.currentRegion < this.regions.size()) {
+ IRegion region = this.regions.get(this.currentRegion);
+ if (currentPosition < region.getOffset())
+ break;
+ int regionEnd = region.getOffset() + region.getLength();
+ if (this.counter >= regionEnd) {
+ this.currentRegion++;
+ continue;
+ }
+ if (this.currentRegion == this.regions.size() - 1
+ || this.regions.get(this.currentRegion + 1).getOffset() > currentPosition) {
+ this.edits.add(getReplaceEdit(this.counter, currentPosition, buffered, region));
+ break;
+ }
+
+ // this edit will span more than one region, split it
+ IRegion nextRegion = this.regions.get(this.currentRegion + 1);
+ int bestSplit = 0;
+ int bestSplitScore = Integer.MAX_VALUE;
+ for (int i = 0; i < buffered.length(); i++) {
+ ReplaceEdit edit1 = getReplaceEdit(this.counter, regionEnd, buffered.substring(0, i), region);
+ ReplaceEdit edit2 = getReplaceEdit(regionEnd, currentPosition, buffered.substring(i), nextRegion);
+ int score = edit1.getLength() + edit1.getText().length() + edit2.getLength() + edit2.getText().length();
+ if (score < bestSplitScore) {
+ bestSplit = i;
+ bestSplitScore = score;
+ }
+ }
+ this.edits.add(getReplaceEdit(this.counter, regionEnd, buffered.substring(0, bestSplit), region));
+ buffered = buffered.substring(bestSplit);
+ this.counter = regionEnd;
}
this.buffer.setLength(0);
this.counter = currentPosition;
}
- private boolean checkRegions(int editStart, int editEnd) {
- while (true) {
- if (this.currentRegion >= this.regions.size())
- return false;
- IRegion region = this.regions.get(this.currentRegion);
- if (editEnd < region.getOffset())
- return false;
- if (editStart < region.getOffset() + region.getLength())
- return true;
- this.currentRegion++;
- }
- }
-
- private TextEdit getReplaceEdit(int editStart, int editEnd, String text) {
- IRegion region = this.regions.get(this.currentRegion);
+ private ReplaceEdit getReplaceEdit(int editStart, int editEnd, String text, IRegion region) {
int regionEnd = region.getOffset() + region.getLength();
if (editStart < region.getOffset() && regionEnd < editEnd) {
int breaksInReplacement = this.tm.countLineBreaksBetween(text, 0, text.length());
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java
index 4e6ad4f..ffd5e02 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/Token.java
@@ -7,6 +7,7 @@
*
* Contributors:
* Mateusz Matela <mateusz.matela@gmail.com> - [formatter] Formatter does not format Java code correctly, especially when max line width is set - https://bugs.eclipse.org/303519
+ * Till Brychcy - Java Code Formatter breaks code if single line comments contain unicode escape - https://bugs.eclipse.org/471090
*******************************************************************************/
package org.eclipse.jdt.internal.formatter;
@@ -24,50 +25,64 @@
*/
public class Token {
+ public static enum WrapMode {
+ /**
+ * Wrap mode for the "Do not wrap" policy. Tokens still should be indented as if wrapped when a preceding line
+ * break cannot be removed due to a line comment or formatting region restriction.
+ */
+ DISABLED,
+ /** Wrap mode for the "Wrap where necessary" policies. */
+ WHERE_NECESSARY,
+ /** Wrap mode for the "Wrap all elements" policies. */
+ TOP_PRIORITY,
+ /**
+ * Wrap mode for tokens that are already in new line before wrapping, but their indentation should be adjusted
+ * in similar way to wrapping. Used for anonymous class body, lambda body and comments inside code.
+ */
+ FORCED
+ }
+
public static class WrapPolicy {
/** Policy used for internal structure of multiline comments to mark tokens that should never be wrapped */
- public final static WrapPolicy DISABLE_WRAP = new WrapPolicy(0, 0, false);
+ public final static WrapPolicy DISABLE_WRAP = new WrapPolicy(WrapMode.DISABLED, 0, 0);
/**
* Policy used for internal structure of multiline comments to mark tokens that can be wrapped only in lines
* that have no other tokens to wrap.
*/
- public final static WrapPolicy SUBSTITUTE_ONLY = new WrapPolicy(0, 0, false);
+ public final static WrapPolicy SUBSTITUTE_ONLY = new WrapPolicy(WrapMode.DISABLED, 0, 0);
- public final int extraIndent;
+ public final WrapMode wrapMode;
public final int wrapParentIndex;
+ public final int groupEndIndex;
+ public final int extraIndent;
public final int structureDepth;
public final float penaltyMultiplier;
public final boolean isFirstInGroup;
public final boolean indentOnColumn;
- public final int topPriorityGroupEnd;
- /**
- * If true, it means the token was in new line even before wrapping, but should be treaded as wrapped token for
- * indentation purposes. Used for anonymous class body, lambda body and comments inside code.
- */
- public final boolean isForced;
- public WrapPolicy(int extraIndent, int wrapParentIndex, int structureDepth, float penaltyMultiplier,
- boolean isFirstInGroup, boolean indentOnColumn, int topPriorityGroupEnd, boolean isForced) {
- this.extraIndent = extraIndent;
+ public WrapPolicy(WrapMode wrapMode, int wrapParentIndex, int groupEndIndex, int extraIndent,
+ int structureDepth, float penaltyMultiplier, boolean isFirstInGroup, boolean indentOnColumn) {
+ assert wrapMode != null && (wrapParentIndex < groupEndIndex || groupEndIndex == -1);
+
+ this.wrapMode = wrapMode;
this.wrapParentIndex = wrapParentIndex;
+ this.groupEndIndex = groupEndIndex;
+ this.extraIndent = extraIndent;
this.structureDepth = structureDepth;
this.penaltyMultiplier = penaltyMultiplier;
this.isFirstInGroup = isFirstInGroup;
this.indentOnColumn = indentOnColumn;
- this.topPriorityGroupEnd = topPriorityGroupEnd;
- this.isForced = isForced;
}
- public WrapPolicy(int extraIndent, int wrapParentIndex, boolean isForced) {
- this(extraIndent, wrapParentIndex, 0, 1, false, false, -1, isForced);
+ public WrapPolicy(WrapMode wrapMode, int wrapParentIndex, int extraIndent) {
+ this(wrapMode, wrapParentIndex, -1, extraIndent, 0, 1, false, false);
+ }
}
- public boolean isTopPriority() {
- return this.topPriorityGroupEnd >= 0;
- }
- }
+ /** Special token type used to mark tokens that store empty line indentation */
+ public static final int TokenNameEMPTY_LINE = 10000;
/** Position in source of the first character. */
public final int originalStart;
@@ -119,9 +134,8 @@
int end = scanner.getCurrentTokenEndPosition();
if (currentToken == TokenNameCOMMENT_LINE) {
// don't include line separator
- String source = scanner.getCurrentTokenString();
- for (int i = source.length() - 1; i > 0; i--) {
- char c = source.charAt(i);
+ while(end >= start) {
+ char c = scanner.source[end];
if (c != '\r' && c != '\n')
break;
end--;
@@ -242,7 +256,8 @@
}
public boolean isWrappable() {
- return this.wrapPolicy != null && !this.wrapPolicy.isForced;
+ WrapPolicy wp = this.wrapPolicy;
+ return wp != null && wp.wrapMode != WrapMode.DISABLED && wp.wrapMode != WrapMode.FORCED;
}
public void setNLSTag(Token nlsTagToken) {
@@ -276,6 +291,8 @@
}
public String toString(String source) {
+ if (this.tokenType == TokenNameEMPTY_LINE)
+ return ""; //$NON-NLS-1$
return source.substring(this.originalStart, this.originalEnd + 1);
}
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java
index 054d8b2..8d18424 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/TokenManager.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2014, 2015 Mateusz Matela and others.
+ * Copyright (c) 2014, 2016 Mateusz Matela and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -10,7 +10,12 @@
*******************************************************************************/
package org.eclipse.jdt.internal.formatter;
-import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.*;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_BLOCK;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_JAVADOC;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameLBRACE;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameNotAToken;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameStringLiteral;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameWHITESPACE;
import java.util.ArrayList;
import java.util.HashMap;
@@ -24,6 +29,7 @@
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.ThrowStatement;
+import org.eclipse.jdt.internal.formatter.Token.WrapMode;
import org.eclipse.jdt.internal.formatter.linewrap.CommentWrapExecutor;
/**
@@ -379,16 +385,19 @@
}
public int findFirstTokenInLine(int startIndex) {
- return findFirstTokenInLine(startIndex, false);
+ return findFirstTokenInLine(startIndex, false, false);
}
- public int findFirstTokenInLine(int startIndex, boolean includeWraps) {
+ public int findFirstTokenInLine(int startIndex, boolean includeWraps, boolean includeForced) {
Token previous = get(startIndex); // going backwards, previous has higher index than current
for (int i = startIndex - 1; i >= 0; i--) {
Token token = get(i);
- int lineBreaks = Math.max(token.getLineBreaksAfter(), previous.getLineBreaksBefore());
- if (lineBreaks > 0 && (!includeWraps || previous.getWrapPolicy() == null))
+ if (token.getLineBreaksAfter() > 0 || previous.getLineBreaksBefore() > 0) {
+ boolean include = previous.getWrapPolicy() != null
+ && (previous.getWrapPolicy().wrapMode == WrapMode.FORCED ? includeForced : includeWraps);
+ if (!include)
return i + 1;
+ }
previous = token;
}
return 0;
@@ -430,8 +439,10 @@
if (this.formatOffTagPairs == null)
return;
for (Token[] pair : this.formatOffTagPairs) {
- int index1 = indexOf(pair[0]);
- int index2 = indexOf(pair[1]);
+ int index1 = findIndex(pair[0].originalStart, -1, false);
+ int index2 = findIndex(pair[1].originalEnd, -1, false);
+ pair[0] = get(index1);
+ pair[1] = get(index2);
Token unformatted = new Token(pair[0].originalStart, pair[1].originalEnd, TokenNameWHITESPACE);
unformatted.setIndent(Math.min(pair[0].getIndent(), findSourcePositionInLine(pair[0].originalStart)));
unformatted.putLineBreaksBefore(pair[0].getLineBreaksBefore());
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java
index 9eb02b7..05fab8d 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/CommentWrapExecutor.java
@@ -23,6 +23,7 @@
import org.eclipse.jdt.internal.formatter.Token;
import org.eclipse.jdt.internal.formatter.TokenManager;
import org.eclipse.jdt.internal.formatter.TokenTraverser;
+import org.eclipse.jdt.internal.formatter.Token.WrapMode;
import org.eclipse.jdt.internal.formatter.Token.WrapPolicy;
public class CommentWrapExecutor extends TokenTraverser {
@@ -225,16 +226,18 @@
if (prefix.tokenType == TokenNameWHITESPACE) {
whitespace = new Token(prefix);
whitespace.breakBefore();
- whitespace.setWrapPolicy(new WrapPolicy(0, commentIndex, false));
+ whitespace.setIndent(indent);
+ whitespace.setWrapPolicy(new WrapPolicy(WrapMode.WHERE_NECESSARY, commentIndex, 0));
prefix = structure.get(1);
+ assert prefix.tokenType == TokenNameCOMMENT_LINE;
}
int prefixEnd = commentToken.originalStart + 1;
- if (prefix.tokenType == TokenNameCOMMENT_LINE)
- prefixEnd = Math.max(prefixEnd, prefix.originalEnd);
+ if (!prefix.hasNLSTag())
+ prefixEnd = Math.max(prefixEnd, prefix.originalEnd); // comments can start with more than 2 slashes
prefix = new Token(commentToken.originalStart, prefixEnd, TokenNameCOMMENT_LINE);
if (whitespace == null) {
prefix.breakBefore();
- prefix.setWrapPolicy(new WrapPolicy(0, commentIndex, false));
+ prefix.setWrapPolicy(new WrapPolicy(WrapMode.WHERE_NECESSARY, commentIndex, 0));
}
int lineStartIndex = whitespace == null ? 0 : 1;
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java
index 8321a34..916751f 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/FieldAligner.java
@@ -21,9 +21,7 @@
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.SimpleName;
-import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
-import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.jdt.internal.formatter.Token;
import org.eclipse.jdt.internal.formatter.TokenManager;
import org.eclipse.jdt.internal.formatter.TokenTraverser;
@@ -62,56 +60,27 @@
}
}
- private final List<List<FieldDeclaration>> fieldAlignGroups = new ArrayList<List<FieldDeclaration>>();
+ private final List<List<FieldDeclaration>> fieldAlignGroups = new ArrayList<>();
final TokenManager tm;
- private final DefaultCodeFormatterOptions options;
-
- public FieldAligner(TokenManager tokenManager, DefaultCodeFormatterOptions options) {
+ public FieldAligner(TokenManager tokenManager) {
this.tm = tokenManager;
- this.options = options;
}
- public void prepareAlign(TypeDeclaration node) {
- List<FieldDeclaration> bodyDeclarations = node.bodyDeclarations();
- ArrayList<FieldDeclaration> alignGroup = new ArrayList<FieldDeclaration>();
- BodyDeclaration previous = null;
+ public void prepareAlign(List<FieldDeclaration> bodyDeclarations) {
+ ArrayList<FieldDeclaration> alignGroup = new ArrayList<>();
for (BodyDeclaration declaration : bodyDeclarations) {
- if (!alignGroup.isEmpty()) {
- if ((declaration instanceof FieldDeclaration) && !areSeparated(previous, declaration)) {
+ if ((declaration instanceof FieldDeclaration)) {
alignGroup.add((FieldDeclaration) declaration);
} else {
alignFields(alignGroup);
- alignGroup = new ArrayList<FieldDeclaration>();
- }
+ alignGroup = new ArrayList<>();
}
- if (alignGroup.isEmpty()) {
- if (declaration instanceof FieldDeclaration)
- alignGroup.add((FieldDeclaration) declaration);
}
- previous = declaration;
- }
alignFields(alignGroup);
}
- private boolean areSeparated(BodyDeclaration declaration1, BodyDeclaration declaration2) {
- // check if there are more empty lines between fields than normal
- if (this.options.number_of_empty_lines_to_preserve <= this.options.blank_lines_before_field)
- return false;
- int maxLineBreaks = 0;
- int from = this.tm.lastIndexIn(declaration1, -1);
- int to = this.tm.firstIndexIn(declaration2, -1);
-
- Token previous = this.tm.get(from);
- for (int i = from + 1; i <= to; i++) {
- Token token = this.tm.get(i);
- maxLineBreaks = Math.max(maxLineBreaks, this.tm.countLineBreaksBetween(previous, token));
- previous = token;
- }
- return maxLineBreaks - 1 > this.options.blank_lines_before_field;
- }
-
private void alignFields(ArrayList<FieldDeclaration> alignGroup) {
if (alignGroup.size() < 2)
return;
@@ -125,7 +94,7 @@
int positionInLine = this.tm.getPositionInLine(nameIndex);
maxNameAlign = Math.max(maxNameAlign, positionInLine);
}
- maxNameAlign = this.tm.toIndent(maxNameAlign, true);
+ maxNameAlign = this.tm.toIndent(maxNameAlign, false);
int maxAssignAlign = 0;
for (FieldDeclaration declaration : alignGroup) {
@@ -142,7 +111,7 @@
maxAssignAlign = Math.max(maxAssignAlign, positionInLine);
}
}
- maxAssignAlign = this.tm.toIndent(maxAssignAlign, true);
+ maxAssignAlign = this.tm.toIndent(maxAssignAlign, false);
for (FieldDeclaration declaration : alignGroup) {
List<VariableDeclarationFragment> fragments = declaration.fragments();
@@ -151,16 +120,9 @@
int assingIndex = this.tm.firstIndexAfter(fragment.getName(), TokenNameEQUAL);
Token assignToken = this.tm.get(assingIndex);
assignToken.setAlign(maxAssignAlign);
-
- int baseIndent = this.tm.getPositionInLine(assingIndex + 1) - assignToken.getIndent();
- int lastIndex = this.tm.lastIndexIn(declaration, -1);
- for (int i = assingIndex + 1; i <= lastIndex; i++) {
- Token token = this.tm.get(i);
- token.setIndent(baseIndent + token.getIndent());
}
}
}
- }
public void alignComments() {
if (this.fieldAlignGroups.isEmpty())
@@ -176,7 +138,7 @@
maxCommentAlign = Math.max(maxCommentAlign,
positionCounter.findMaxPosition(firstIndexInLine, lastIndex));
}
- maxCommentAlign = this.tm.toIndent(maxCommentAlign, true);
+ maxCommentAlign = this.tm.toIndent(maxCommentAlign, false);
for (FieldDeclaration declaration : alignGroup) {
int typeIndex = this.tm.firstIndexIn(declaration.getType(), -1);
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java
index 791c385..5f906dc 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapExecutor.java
@@ -26,6 +26,7 @@
import org.eclipse.jdt.internal.formatter.Token;
import org.eclipse.jdt.internal.formatter.TokenManager;
import org.eclipse.jdt.internal.formatter.TokenTraverser;
+import org.eclipse.jdt.internal.formatter.Token.WrapMode;
import org.eclipse.jdt.internal.formatter.Token.WrapPolicy;
public class WrapExecutor {
@@ -74,8 +75,6 @@
public static final WrapResult NO_WRAP_NEEDED = new WrapResult(0, 0, null);
- public static final WrapResult TOP_PRIORITY_WRAP_MET = new WrapResult(0, 0, null);
-
public final double penalty;
public final int totalExtraLines;
/**
@@ -91,6 +90,17 @@
}
}
+ private static class WrapRestartThrowable extends Throwable {
+ private static final long serialVersionUID = -2980600077230803443L; // backward compatible
+
+ public final int topPriorityWrap;
+
+ public WrapRestartThrowable(int topPriorityWrap) {
+ super(null, null, false, false);
+ this.topPriorityWrap = topPriorityWrap;
+ }
+ }
+
private class LineAnalyzer extends TokenTraverser {
final private CommentWrapExecutor commentWrapper;
@@ -133,10 +143,10 @@
if (token.isWrappable()) {
WrapPolicy wrapPolicy = token.getWrapPolicy();
- if (wrapPolicy.isTopPriority() && getLineBreaksBefore() == 0
+ if (wrapPolicy.wrapMode == WrapMode.TOP_PRIORITY && getLineBreaksBefore() == 0
&& index > this.currentTopPriorityGroupEnd) {
this.topPriorityGroupStarts.add(index);
- this.currentTopPriorityGroupEnd = wrapPolicy.topPriorityGroupEnd;
+ this.currentTopPriorityGroupEnd = wrapPolicy.groupEndIndex;
}
if (this.firstPotentialWrap < 0 && getWrapIndent(token) < this.counter)
this.firstPotentialWrap = index;
@@ -274,8 +284,6 @@
final TokenManager tm;
final DefaultCodeFormatterOptions options;
- private int topPriorityWrapIndex;
-
private final WrapInfo wrapInfoTemp = new WrapInfo();
public WrapExecutor(TokenManager tokenManager, DefaultCodeFormatterOptions options) {
@@ -286,86 +294,102 @@
public void executeWraps() {
int index = 0;
- mainLoop: while (index < this.tm.size()) {
+ while (index < this.tm.size()) {
Token token = this.tm.get(index);
- handleOnColumnIndent(index, token.getWrapPolicy());
- // this might be a pre-existing wrap that should trigger other top priority wraps
- int jumpToIndex = handleTopPriorityWraps(index);
- if (jumpToIndex >= 0) {
- index = jumpToIndex;
- continue mainLoop;
+ while (true) {
+ try {
+ int currentIndent = getWrapIndent(token);
+ this.wrapSearchResults.clear();
+ index = applyWraps(index, currentIndent);
+ break;
+ } catch (WrapRestartThrowable e) {
+ handleTopPriorityWraps(e);
+ }
}
-
- // determine wraps for incoming line
- int currentIndent = getWrapIndent(token);
- boolean isLineWrapped = token.isWrappable();
this.wrapSearchResults.clear();
- WrapResult wrapResult = findWraps(index, currentIndent);
- if (wrapResult == WrapResult.TOP_PRIORITY_WRAP_MET) {
- jumpToIndex = handleTopPriorityWraps(this.topPriorityWrapIndex);
- assert jumpToIndex >= 0;
- index = Math.min(index, jumpToIndex);
- continue mainLoop;
+ this.usedTopPriorityWraps.clear();
}
- // apply wraps and indents
- WrapInfo wrapInfo = wrapResult.nextWrap;
- while (wrapInfo != null) {
- isLineWrapped = true;
- for (; index < wrapInfo.wrapTokenIndex; index++) {
- token = this.tm.get(index);
- if (shouldForceWrap(token, currentIndent)) {
- currentIndent = token.getIndent();
- wrapInfo = new WrapInfo(index, currentIndent);
- findWrapsCached(index, currentIndent);
- break;
- }
- token.setIndent(currentIndent);
- }
- token = this.tm.get(index);
- token.breakBefore();
- token.setIndent(currentIndent = wrapInfo.indent);
- handleOnColumnIndent(index, token.getWrapPolicy());
- jumpToIndex = handleTopPriorityWraps(index);
- if (jumpToIndex >= 0) {
- index = jumpToIndex;
- continue mainLoop;
- }
- wrapInfo = this.wrapSearchResults.get(wrapInfo).nextWrap;
- }
-
- // apply indent until the beginning of the next line
- token.setIndent(currentIndent);
- for (index++; index < this.tm.size(); index++) {
- if (token.getLineBreaksAfter() > 0)
- break;
- token = this.tm.get(index);
- if (token.isNextLineOnWrap() && isLineWrapped)
- token.breakBefore();
- if (token.getLineBreaksBefore() > 0)
- break;
- if (shouldForceWrap(token, currentIndent))
- currentIndent = token.getIndent();
- token.setIndent(currentIndent);
- }
- }
- this.wrapSearchResults.clear();
- this.usedTopPriorityWraps.clear();
-
this.tm.traverse(0, new NLSTagHandler());
+ }
+
+ private int applyWraps(int index, int indent) throws WrapRestartThrowable {
+ WrapInfo wrapInfo = findWrapsCached(index, indent).nextWrap;
+ Token token = this.tm.get(index);
+ index++;
+ token.setIndent(indent);
+ int groupEnd = token.getWrapPolicy() != null ? token.getWrapPolicy().groupEndIndex : -1;
+ while (index < this.tm.size()) {
+ token = this.tm.get(index);
+ if (token.isNextLineOnWrap() && this.tm.get(this.tm.findFirstTokenInLine(index)).isWrappable()) {
+ token.breakBefore();
+ return index;
+ }
+ while (wrapInfo != null && wrapInfo.wrapTokenIndex < index)
+ wrapInfo = this.wrapSearchResults.get(wrapInfo).nextWrap;
+ if (wrapInfo != null && wrapInfo.wrapTokenIndex == index) {
+ token.breakBefore();
+ handleOnColumnIndent(index, token.getWrapPolicy());
+ checkTopPriorityWraps(index);
+ index = applyWraps(index, wrapInfo.indent);
+ continue;
+ }
+
+ boolean isNewLine = this.tm.get(index - 1).getLineBreaksAfter() > 0 || token.getLineBreaksBefore() > 0;
+ if (isNewLine) {
+ if (token.getWrapPolicy() != null) {
+ handleOnColumnIndent(index, token.getWrapPolicy());
+ checkTopPriorityWraps(index);
+ int newIndent = getWrapIndent(token);
+ if (newIndent < indent)
+ return index;
+ wrapInfo = findWrapsCached(index, newIndent).nextWrap;
+ if (newIndent > indent) {
+ index = applyWraps(index, newIndent);
+ continue;
+ }
+ } else if (index > groupEnd) {
+ return index;
+ }
+ } else {
+ checkForceWrap(token, index, indent);
+ }
+
+ token.setIndent(indent);
+ index++;
+ }
+ return index;
}
- private WrapResult findWrapsCached(int startTokenIndex, int indent) {
+ private WrapResult findWrapsCached(int startTokenIndex, int indent) throws WrapRestartThrowable {
this.wrapInfoTemp.wrapTokenIndex = startTokenIndex;
this.wrapInfoTemp.indent = indent;
WrapResult wrapResult = this.wrapSearchResults.get(this.wrapInfoTemp);
+ if (wrapResult == null && this.wrapSearchResults.containsKey(this.wrapInfoTemp))
+ return null; // no wrap needed
+
+ // pre-existing result may be based on different wrapping of earlier tokens and therefore be wrong
+ WrapResult wr = wrapResult;
+ while (wr != null && wr.nextWrap != null) {
+ WrapInfo wi = wr.nextWrap;
+ Token token = this.tm.get(wi.wrapTokenIndex);
+ if (token.getWrapPolicy().wrapParentIndex < startTokenIndex && getWrapIndent(token) != wi.indent) {
+ wrapResult = null;
+ break;
+ }
+ wr = this.wrapSearchResults.get(wi);
+ }
+
if (wrapResult == null) {
Token token = this.tm.get(startTokenIndex);
boolean wasLineBreak = token.getLineBreaksBefore() > 0;
token.breakBefore();
+ try {
wrapResult = findWraps(startTokenIndex, indent);
+ } finally {
if (!wasLineBreak)
token.clearLineBreaksBefore();
+ }
WrapInfo wrapInfo = new WrapInfo(startTokenIndex, indent);
this.wrapSearchResults.put(wrapInfo, wrapResult);
@@ -377,7 +401,7 @@
* The main algorithm that looks for optimal places to wrap.
* Calls itself recursively to get results for wrapped sub-lines.
*/
- private WrapResult findWraps(int wrapTokenIndex, int indent) {
+ private WrapResult findWraps(int wrapTokenIndex, int indent) throws WrapRestartThrowable {
final int lastIndex = this.lineAnalyzer.analyzeLine(wrapTokenIndex, indent);
final boolean lineExceeded = this.lineAnalyzer.lineExceeded;
final int lastPosition = this.lineAnalyzer.getLastPosition();
@@ -390,7 +414,7 @@
final int[] topPriorityGroupStarts = toArray(this.lineAnalyzer.topPriorityGroupStarts);
int topPriorityIndex = topPriorityGroupStarts.length - 1;
int nearestGroupEnd = topPriorityIndex == -1 ? 0
- : this.tm.get(topPriorityGroupStarts[topPriorityIndex]).getWrapPolicy().topPriorityGroupEnd;
+ : this.tm.get(topPriorityGroupStarts[topPriorityIndex]).getWrapPolicy().groupEndIndex;
double bestTotalPenalty = getWrapPenalty(wrapTokenIndex, indent, lastIndex + 1, -1, WrapResult.NO_WRAP_NEEDED);
int bestExtraLines = lineExceeded ? Integer.MAX_VALUE : extraLines; // if line is exceeded, accept every wrap
@@ -402,7 +426,8 @@
if ((!lineExceeded || firstPotentialWrap < 0) && lastIndex + 1 < this.tm.size()) {
Token nextLineToken = this.tm.get(lastIndex + 1);
- if (nextLineToken.isWrappable() && (this.tm.get(lastIndex).isComment() || nextLineToken.isComment())) {
+ if ((nextLineToken.getWrapPolicy() != null && nextLineToken.getWrapPolicy().wrapMode != WrapMode.FORCED)
+ && (this.tm.get(lastIndex).isComment() || nextLineToken.isComment())) {
// this might be a pre-existing wrap forced by a comment, calculate penalties as normal
bestIndent = getWrapIndent(nextLineToken);
bestNextWrap = lastIndex + 1;
@@ -414,8 +439,7 @@
if (firstPotentialWrap < 0 && lineExceeded) {
if (topPriorityGroupStarts.length > 0) {
- this.topPriorityWrapIndex = topPriorityGroupStarts[0];
- return WrapResult.TOP_PRIORITY_WRAP_MET;
+ checkTopPriorityWraps(topPriorityGroupStarts[0]);
}
// Report high number of extra lines to encourage the algorithm to look
@@ -439,7 +463,7 @@
assert i == topPriorityGroupStarts[topPriorityIndex];
topPriorityIndex--;
nearestGroupEnd = topPriorityIndex == -1 ? 0
- : this.tm.get(topPriorityGroupStarts[topPriorityIndex]).getWrapPolicy().topPriorityGroupEnd;
+ : this.tm.get(topPriorityGroupStarts[topPriorityIndex]).getWrapPolicy().groupEndIndex;
}
if (!token.isWrappable())
@@ -448,9 +472,6 @@
int nextWrapIndent = getWrapIndent(token);
WrapResult nextWrapResult = findWrapsCached(i, nextWrapIndent);
- if (nextWrapResult == WrapResult.TOP_PRIORITY_WRAP_MET)
- continue;
-
double totalPenalty = getWrapPenalty(wrapTokenIndex, indent, i, nextWrapIndent, nextWrapResult);
int totalExtraLines = extraLines + nextWrapResult.totalExtraLines;
boolean isBetter = totalExtraLines < bestExtraLines || bestExtraLines == Integer.MAX_VALUE;
@@ -468,8 +489,7 @@
}
if (bestNextWrap == -1 && lineExceeded && topPriorityGroupStarts.length > 0) {
- this.topPriorityWrapIndex = topPriorityGroupStarts[0];
- return WrapResult.TOP_PRIORITY_WRAP_MET;
+ checkTopPriorityWraps(topPriorityGroupStarts[0]);
}
return new WrapResult(bestTotalPenalty, bestExtraLines,
@@ -477,7 +497,7 @@
}
private double getWrapPenalty(int lineStartIndex, int lineIndent, int wrapIndex, int wrapIndent,
- WrapResult wrapResult) {
+ WrapResult wrapResult) throws WrapRestartThrowable {
WrapPolicy wrapPolicy = null;
Token wrapToken = null;
if (wrapIndex < this.tm.size()) {
@@ -521,12 +541,12 @@
// a wrap of the same parent (bar2). If so, then bar1 must be wrapped (so give it negative penalty).
// Update: Actually, every token that is followed by a higher level depth wrap should be also wrapped,
// as long as this next wrap is not the last in line and the token is not the first in its wrap group.
- WrapResult nextWrapResult = wrapResult;
+ WrapInfo nextWrap = wrapResult.nextWrap;
boolean checkDepth = wrapToken != null && wrapToken.isWrappable()
&& (lineStartWrapPolicy == null || wrapPolicy.structureDepth >= lineStartWrapPolicy.structureDepth);
double penaltyDiff = 0;
- while (checkDepth && nextWrapResult.nextWrap != null) {
- WrapPolicy nextPolicy = this.tm.get(nextWrapResult.nextWrap.wrapTokenIndex).getWrapPolicy();
+ while (checkDepth && nextWrap != null) {
+ WrapPolicy nextPolicy = this.tm.get(nextWrap.wrapTokenIndex).getWrapPolicy();
if (nextPolicy.wrapParentIndex == wrapPolicy.wrapParentIndex
|| (penaltyDiff != 0 && !wrapPolicy.isFirstInGroup)) {
penalty -= penaltyDiff * 1.25;
@@ -535,7 +555,7 @@
if (nextPolicy.structureDepth <= wrapPolicy.structureDepth)
break;
penaltyDiff = Math.max(penaltyDiff, getPenalty(nextPolicy));
- nextWrapResult = this.wrapSearchResults.get(nextWrapResult.nextWrap);
+ nextWrap = findWrapsCached(nextWrap.wrapTokenIndex, nextWrap.indent).nextWrap;
}
return penalty + wrapResult.penalty;
@@ -545,40 +565,40 @@
return Math.exp(policy.structureDepth) * policy.penaltyMultiplier;
}
- private boolean shouldForceWrap(Token token, int currentIndent) {
+ private void checkForceWrap(Token token, int index, int currentIndent) throws WrapRestartThrowable {
// A token that will have smaller indent when wrapped than the current line indent,
// should be wrapped because it's a low depth token following some complex wraps of higher depth.
// This rule could not be implemented in getWrapPenalty() because a token's wrap indent may depend
// on wraps in previous lines, which are not determined yet when the token's penalty is calculated.
- if (token.isWrappable() && this.options.wrap_outer_expressions_when_nested) {
- int indent = getWrapIndent(token);
- if (indent < currentIndent) {
+ if (token.isWrappable() && this.options.wrap_outer_expressions_when_nested
+ && getWrapIndent(token) < currentIndent) {
+ WrapPolicy lineStartPolicy = this.tm.get(this.tm.findFirstTokenInLine(index, false, true)).getWrapPolicy();
+ if (lineStartPolicy != null && lineStartPolicy.wrapMode != WrapMode.FORCED) {
token.breakBefore();
- token.setIndent(indent);
- return true;
+ throw new WrapRestartThrowable(-1);
+ }
}
}
- return false;
+
+ private void checkTopPriorityWraps(int wrapIndex) throws WrapRestartThrowable {
+ WrapPolicy wrapPolicy = this.tm.get(wrapIndex).getWrapPolicy();
+ if (wrapPolicy != null && wrapPolicy.wrapMode == WrapMode.TOP_PRIORITY
+ && !this.usedTopPriorityWraps.contains(wrapPolicy))
+ throw new WrapRestartThrowable(wrapIndex);
}
- /**
- * @return index of the first token in the top priority group that given token belongs to or -1 if it doesn't belong
- * to any top priority.
- */
- private int handleTopPriorityWraps(int wrapIndex) {
- // wrap all tokens in the same top priority group and jump back to the first one
+ private void handleTopPriorityWraps(WrapRestartThrowable restartException) {
+ int wrapIndex = restartException.topPriorityWrap;
+ if (wrapIndex < 0)
+ return;
WrapPolicy wrapPolicy = this.tm.get(wrapIndex).getWrapPolicy();
- if (wrapPolicy == null || !wrapPolicy.isTopPriority() || this.usedTopPriorityWraps.contains(wrapPolicy))
- return -1;
- int firstTokenIndex = -1;
int parentIndex = wrapPolicy.wrapParentIndex;
for (int i = wrapIndex; i > parentIndex; i--) {
Token token = this.tm.get(i);
wrapPolicy = token.getWrapPolicy();
if (wrapPolicy != null && wrapPolicy.wrapParentIndex == parentIndex) {
- if (wrapPolicy.isTopPriority()) {
+ if (wrapPolicy.wrapMode == WrapMode.TOP_PRIORITY) {
token.breakBefore();
- firstTokenIndex = i;
this.usedTopPriorityWraps.add(wrapPolicy);
}
if (wrapPolicy.isFirstInGroup)
@@ -594,14 +614,13 @@
} else if (wrapPolicy != null && wrapPolicy.wrapParentIndex == parentIndex) {
if (wrapPolicy.isFirstInGroup)
break;
- if (wrapPolicy.isTopPriority()) {
+ if (wrapPolicy.wrapMode == WrapMode.TOP_PRIORITY) {
token.breakBefore();
this.usedTopPriorityWraps.add(wrapPolicy);
}
}
breakAfterPrevious = token.getLineBreaksAfter() > 0;
}
- return firstTokenIndex;
}
private int[] toArray(List<Integer> list) {
@@ -634,8 +653,8 @@
int getWrapIndent(Token token) {
WrapPolicy policy = token.getWrapPolicy();
- if (policy == null || (token.getLineBreaksBefore() > 1 && !policy.isForced && !policy.isTopPriority()))
- return token.getIndent(); // no additional indentation after an empty line
+ if (policy == null)
+ return token.getIndent();
if (this.options.never_indent_line_comments_on_first_column && token.tokenType == TokenNameCOMMENT_LINE
&& token.getIndent() == 0)
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java
index b973b6f..d4f54d5 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/internal/formatter/linewrap/WrapPreparator.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2014, 2015 Mateusz Matela and others.
+ * Copyright (c) 2014, 2016 Mateusz Matela and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -12,6 +12,7 @@
package org.eclipse.jdt.internal.formatter.linewrap;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOLON;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMA;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_BLOCK;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_JAVADOC;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameCOMMENT_LINE;
@@ -23,11 +24,14 @@
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameQUESTION;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameRBRACE;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameRPAREN;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameSEMICOLON;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameStringLiteral;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameextends;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameimplements;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNameIdentifier;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamenew;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamesuper;
+import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamethis;
import static org.eclipse.jdt.internal.compiler.parser.TerminalTokens.TokenNamethrows;
import java.util.ArrayList;
@@ -38,6 +42,7 @@
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.ArrayInitializer;
import org.eclipse.jdt.core.dom.Assignment;
@@ -49,6 +54,7 @@
import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
import org.eclipse.jdt.core.dom.EnumDeclaration;
import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.IfStatement;
import org.eclipse.jdt.core.dom.ImportDeclaration;
@@ -58,10 +64,13 @@
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.NormalAnnotation;
+import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
+import org.eclipse.jdt.core.dom.SuperFieldAccess;
import org.eclipse.jdt.core.dom.SuperMethodInvocation;
+import org.eclipse.jdt.core.dom.ThisExpression;
import org.eclipse.jdt.core.dom.TryStatement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
@@ -74,12 +83,54 @@
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions;
import org.eclipse.jdt.internal.formatter.DefaultCodeFormatterOptions.Alignment;
import org.eclipse.jdt.internal.formatter.Token;
+import org.eclipse.jdt.internal.formatter.Token.WrapMode;
import org.eclipse.jdt.internal.formatter.Token.WrapPolicy;
import org.eclipse.jdt.internal.formatter.TokenManager;
import org.eclipse.jdt.internal.formatter.TokenTraverser;
+import org.eclipse.jface.text.IRegion;
public class WrapPreparator extends ASTVisitor {
+ /**
+ * Helper for common handling of all expressions that should be treated the same as {@link FieldAccess}
+ */
+ private static class FieldAccessAdapter {
+ final Expression accessExpression;
+
+ public FieldAccessAdapter(Expression expression) {
+ this.accessExpression = expression;
+ }
+
+ public static boolean isFieldAccess(ASTNode expr) {
+ return expr instanceof FieldAccess || expr instanceof QualifiedName || expr instanceof ThisExpression
+ || expr instanceof SuperFieldAccess;
+ }
+
+ public Expression getExpression() {
+ if (this.accessExpression instanceof FieldAccess)
+ return ((FieldAccess) this.accessExpression).getExpression();
+ if (this.accessExpression instanceof QualifiedName)
+ return ((QualifiedName) this.accessExpression).getQualifier();
+ if (this.accessExpression instanceof ThisExpression)
+ return ((ThisExpression) this.accessExpression).getQualifier();
+ if (this.accessExpression instanceof SuperFieldAccess)
+ return ((SuperFieldAccess) this.accessExpression).getQualifier();
+ throw new AssertionError();
+ }
+
+ public int getIdentifierIndex(TokenManager tm) {
+ if (this.accessExpression instanceof FieldAccess)
+ return tm.firstIndexIn(((FieldAccess) this.accessExpression).getName(), TokenNameIdentifier);
+ if (this.accessExpression instanceof QualifiedName)
+ return tm.firstIndexIn(((QualifiedName) this.accessExpression).getName(), TokenNameIdentifier);
+ if (this.accessExpression instanceof ThisExpression)
+ return tm.lastIndexIn(this.accessExpression, TokenNamethis);
+ if (this.accessExpression instanceof SuperFieldAccess)
+ return tm.lastIndexIn(this.accessExpression, TokenNamesuper);
+ throw new AssertionError();
+ }
+ }
+
private final static Map<Operator, Integer> OPERATOR_PRECEDENCE;
static {
HashMap<Operator, Integer> precedence = new HashMap<Operator, Integer>();
@@ -106,7 +157,7 @@
final DefaultCodeFormatterOptions options;
final int kind;
- FieldAligner fieldAligner;
+ final FieldAligner fieldAligner;
int importsStart = -1, importsEnd = -1;
@@ -115,6 +166,8 @@
* parameters
*/
private List<Integer> wrapIndexes = new ArrayList<Integer>();
+ /** Indexes for wraps that shouldn't happen but should be indented if cannot be removed */
+ private List<Integer> secondaryWrapIndexes = new ArrayList<Integer>();
private List<Float> wrapPenalties = new ArrayList<Float>();
private int wrapParentIndex = -1;
private int wrapGroupEnd = -1;
@@ -125,11 +178,17 @@
this.tm = tokenManager;
this.options = options;
this.kind = kind;
+
+ this.fieldAligner = new FieldAligner(this.tm);
}
@Override
public boolean preVisit2(ASTNode node) {
this.currentDepth++;
+
+ assert this.wrapIndexes.isEmpty() && this.secondaryWrapIndexes.isEmpty() && this.wrapPenalties.isEmpty();
+ assert this.wrapParentIndex == -1 && this.wrapGroupEnd == -1;
+
boolean isMalformed = (node.getFlags() & ASTNode.MALFORMED) != 0;
if (isMalformed) {
this.tm.addDisableFormatTokenPair(this.tm.firstTokenIn(node, -1), this.tm.lastTokenIn(node, -1));
@@ -173,19 +232,28 @@
if (!superInterfaceTypes.isEmpty()) {
int implementsToken = node.isInterface() ? TokenNameextends : TokenNameimplements;
this.wrapParentIndex = this.tm.lastIndexIn(node.getName(), -1);
- this.wrapGroupEnd = this.tm.lastIndexIn(superInterfaceTypes.get(superInterfaceTypes.size() - 1), -1);
this.wrapIndexes.add(this.tm.firstIndexBefore(superInterfaceTypes.get(0), implementsToken));
- for (Type type : superInterfaceTypes)
- this.wrapIndexes.add(this.tm.firstIndexIn(type, -1));
+ prepareElementsList(superInterfaceTypes, TokenNameCOMMA, -1);
handleWrap(this.options.alignment_for_superinterfaces_in_type_declaration, PREFERRED);
}
- if (this.options.align_type_members_on_columns) {
- if (this.fieldAligner == null) {
- this.fieldAligner = new FieldAligner(this.tm, this.options);
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
+
+ return true;
}
- this.fieldAligner.prepareAlign(node);
+
+ @Override
+ public boolean visit(AnnotationTypeDeclaration node) {
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
+ return true;
}
+
+ @Override
+ public boolean visit(AnonymousClassDeclaration node) {
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
return true;
}
@@ -205,26 +273,28 @@
List<Type> exceptionTypes = node.thrownExceptionTypes();
if (!exceptionTypes.isEmpty()) {
- this.wrapParentIndex = this.tm.firstIndexBefore(exceptionTypes.get(0), TokenNameRPAREN);
- this.wrapGroupEnd = this.tm.lastIndexIn(exceptionTypes.get(exceptionTypes.size() - 1), -1);
int wrappingOption = node.isConstructor()
? this.options.alignment_for_throws_clause_in_constructor_declaration
: this.options.alignment_for_throws_clause_in_method_declaration;
- for (Type exceptionType : exceptionTypes)
- this.wrapIndexes.add(this.tm.firstIndexIn(exceptionType, -1));
+ if ((wrappingOption & Alignment.M_INDENT_ON_COLUMN) == 0)
+ this.wrapParentIndex = this.tm.firstIndexAfter(node.getName(), TokenNameLPAREN);
+ prepareElementsList(exceptionTypes, TokenNameCOMMA, TokenNameRPAREN);
// instead of the first exception type, wrap the "throws" token
this.wrapIndexes.set(0, this.tm.firstIndexBefore(exceptionTypes.get(0), TokenNamethrows));
handleWrap(wrappingOption, 0.5f);
}
if (!node.isConstructor()) {
+ this.wrapParentIndex = this.tm.findFirstTokenInLine(this.tm.firstIndexIn(node.getName(), -1));
List<TypeParameter> typeParameters = node.typeParameters();
if (!typeParameters.isEmpty())
this.wrapIndexes.add(this.tm.firstIndexIn(typeParameters.get(0), -1));
- if (node.getReturnType2() != null)
- this.wrapIndexes.add(this.tm.firstIndexIn(node.getReturnType2(), -1));
+ if (node.getReturnType2() != null) {
+ int returTypeIndex = this.tm.firstIndexIn(node.getReturnType2(), -1);
+ if (returTypeIndex != this.wrapParentIndex)
+ this.wrapIndexes.add(returTypeIndex);
+ }
this.wrapIndexes.add(this.tm.firstIndexIn(node.getName(), -1));
- this.wrapParentIndex = this.tm.findFirstTokenInLine(this.tm.firstIndexIn(node.getName(), -1));
this.wrapGroupEnd = this.tm.lastIndexIn(node.getName(), -1);
handleWrap(this.options.alignment_for_method_declaration);
}
@@ -234,24 +304,47 @@
@Override
public boolean visit(EnumDeclaration node) {
List<EnumConstantDeclaration> enumConstants = node.enumConstants();
+ int constantsEnd = -1;
if (!enumConstants.isEmpty()) {
for (EnumConstantDeclaration constant : enumConstants)
this.wrapIndexes.add(this.tm.firstIndexIn(constant, -1));
- this.wrapParentIndex = this.tm.firstIndexBefore(enumConstants.get(0), TokenNameLBRACE);
- this.wrapGroupEnd = this.tm.lastIndexIn(enumConstants.get(enumConstants.size() - 1), -1);
+ this.wrapParentIndex = (this.options.alignment_for_enum_constants & Alignment.M_INDENT_ON_COLUMN) > 0
+ ? this.tm.firstIndexBefore(enumConstants.get(0), TokenNameLBRACE) : this.tm.firstIndexIn(node, -1);
+ this.wrapGroupEnd = constantsEnd = this.tm.lastIndexIn(enumConstants.get(enumConstants.size() - 1), -1);
handleWrap(this.options.alignment_for_enum_constants, node);
}
+ if (!this.options.join_wrapped_lines) {
+ // preserve a line break between the last comma and semicolon
+ int commaIndex = -1;
+ int i = constantsEnd > 0 ? constantsEnd : this.tm.firstIndexAfter(node.getName(), TokenNameLBRACE);
+ while (++i < this.tm.size()) {
+ Token t = this.tm.get(i);
+ if (t.isComment())
+ continue;
+ if (t.tokenType == TokenNameCOMMA) {
+ commaIndex = i;
+ continue;
+ }
+ if (t.tokenType == TokenNameSEMICOLON && commaIndex >= 0
+ && this.tm.countLineBreaksBetween(this.tm.get(commaIndex), t) == 1) {
+ t.setWrapPolicy(new WrapPolicy(WrapMode.WHERE_NECESSARY, commaIndex, 0));
+ }
+ break;
+ }
+ }
+
List<Type> superInterfaceTypes = node.superInterfaceTypes();
if (!superInterfaceTypes.isEmpty()) {
- this.wrapIndexes.add(this.tm.firstIndexBefore(superInterfaceTypes.get(0), TokenNameimplements));
- for (Type type : superInterfaceTypes)
- this.wrapIndexes.add(this.tm.firstIndexIn(type, -1));
this.wrapParentIndex = this.tm.lastIndexIn(node.getName(), -1);
- this.wrapGroupEnd = this.tm.lastIndexIn(superInterfaceTypes.get(superInterfaceTypes.size() - 1), -1);
- this.wrapPenalties.add(PREFERRED);
- handleWrap(this.options.alignment_for_superinterfaces_in_enum_declaration, node);
+ this.wrapIndexes.add(this.tm.firstIndexBefore(superInterfaceTypes.get(0), TokenNameimplements));
+ prepareElementsList(superInterfaceTypes, TokenNameCOMMA, -1);
+ handleWrap(this.options.alignment_for_superinterfaces_in_enum_declaration, PREFERRED);
}
+
+ if (this.options.align_type_members_on_columns)
+ this.fieldAligner.prepareAlign(node.bodyDeclarations());
+
return true;
}
@@ -277,8 +370,10 @@
while (expression instanceof MethodInvocation) {
invocation = (MethodInvocation) expression;
expression = invocation.getExpression();
- if (expression != null)
+ if (expression != null) {
this.wrapIndexes.add(this.tm.firstIndexBefore(invocation.getName(), TokenNameDOT));
+ this.secondaryWrapIndexes.add(this.tm.firstIndexIn(invocation.getName(), TokenNameIdentifier));
+ }
}
Collections.reverse(this.wrapIndexes);
this.wrapParentIndex = (expression != null) ? this.tm.lastIndexIn(expression, -1)
@@ -322,6 +417,62 @@
}
@Override
+ public boolean visit(FieldAccess node) {
+ handleFieldAccess(node);
+ return true;
+ }
+
+ @Override
+ public boolean visit(QualifiedName node) {
+ handleFieldAccess(node);
+ return true;
+ }
+
+ @Override
+ public boolean visit(ThisExpression node) {
+ handleFieldAccess(node);
+ return true;
+ }
+
+ @Override
+ public boolean visit(SuperFieldAccess node) {
+ handleFieldAccess(node);
+ return true;
+ }
+
+ private void handleFieldAccess(Expression node) {
+ boolean isAccessChainRoot = !FieldAccessAdapter.isFieldAccess(node.getParent());
+ if (!isAccessChainRoot)
+ return;
+
+ Expression expression = node;
+ FieldAccessAdapter access = null;
+ while (FieldAccessAdapter.isFieldAccess(expression)) {
+ access = new FieldAccessAdapter(expression);
+ int nameIndex = access.getIdentifierIndex(this.tm);
+ // find a dot preceding the name, may not be there
+ for (int i = nameIndex - 1; i > this.tm.firstIndexIn(node, -1); i--) {
+ Token t = this.tm.get(i);
+ if (t.tokenType == TokenNameDOT) {
+ this.wrapIndexes.add(i);
+ this.secondaryWrapIndexes.add(nameIndex);
+ }
+ if (!t.isComment() && t.tokenType != TokenNamesuper)
+ break;
+ }
+ expression = access.getExpression();
+ }
+ Collections.reverse(this.wrapIndexes);
+ this.wrapParentIndex = this.tm.lastIndexIn(expression != null ? expression : access.accessExpression, -1);
+ boolean isFollowedByInvocation = node.getParent() instanceof MethodInvocation
+ && node.getLocationInParent() == MethodInvocation.EXPRESSION_PROPERTY;
+ this.wrapGroupEnd = isFollowedByInvocation ? this.tm.lastIndexIn(node.getParent(), -1)
+ : new FieldAccessAdapter(node).getIdentifierIndex(this.tm);
+ // TODO need configuration for this, now only handles line breaks that cannot be removed
+ handleWrap(Alignment.M_NO_ALIGNMENT);
+ }
+
+ @Override
public boolean visit(InfixExpression node) {
Integer operatorPrecedence = OPERATOR_PRECEDENCE.get(node.getOperator());
if (operatorPrecedence == null)
@@ -333,7 +484,8 @@
findTokensToWrap(node, 0);
this.wrapParentIndex = this.wrapIndexes.remove(0);
this.wrapGroupEnd = this.tm.lastIndexIn(node, -1);
- if ((this.options.alignment_for_binary_expression & Alignment.M_INDENT_ON_COLUMN) != 0)
+ if ((this.options.alignment_for_binary_expression & Alignment.M_INDENT_ON_COLUMN) != 0
+ && this.wrapParentIndex > 0)
this.wrapParentIndex--;
for (int i = this.wrapParentIndex; i >= 0; i--) {
if (!this.tm.get(i).isComment()) {
@@ -367,6 +519,7 @@
assert node.getOperator().toString().equals(this.tm.toString(indexBefore));
int indexAfter = this.tm.firstIndexIn(operand, -1);
this.wrapIndexes.add(this.options.wrap_before_binary_operator ? indexBefore : indexAfter);
+ this.secondaryWrapIndexes.add(this.options.wrap_before_binary_operator ? indexAfter : indexBefore);
if (!this.options.join_wrapped_lines) {
// TODO there should be an option for never joining wraps on opposite side of the operator
@@ -393,6 +546,8 @@
public boolean visit(ConditionalExpression node) {
this.wrapIndexes.add(this.tm.firstIndexAfter(node.getExpression(), TokenNameQUESTION));
this.wrapIndexes.add(this.tm.firstIndexAfter(node.getThenExpression(), TokenNameCOLON));
+ this.secondaryWrapIndexes.add(this.tm.firstIndexIn(node.getThenExpression(), -1));
+ this.secondaryWrapIndexes.add(this.tm.firstIndexIn(node.getElseExpression(), -1));
this.wrapParentIndex = this.tm.lastIndexIn(node.getExpression(), -1);
this.wrapGroupEnd = this.tm.lastIndexIn(node, -1);
handleWrap(this.options.alignment_for_conditional_expression);
@@ -403,10 +558,7 @@
public boolean visit(ArrayInitializer node) {
List<Expression> expressions = node.expressions();
if (!expressions.isEmpty()) {
- for (Expression expression : expressions)
- this.wrapIndexes.add(this.tm.firstIndexIn(expression, -1));
- this.wrapParentIndex = this.tm.firstIndexBefore(expressions.get(0), TokenNameLBRACE);
- this.wrapGroupEnd = this.tm.lastIndexIn(node, -1);
+ prepareElementsList(expressions, TokenNameCOMMA, TokenNameLBRACE);
handleWrap(this.options.alignment_for_expressions_in_array_initializer, node);
}
if (!this.options.join_wrapped_lines
@@ -416,8 +568,8 @@
Token closingBrace = this.tm.get(closingBraceIndex);
if (this.tm.countLineBreaksBetween(this.tm.get(closingBraceIndex - 1), closingBrace) == 1) {
int openingBraceIndex = this.tm.firstIndexIn(node, TokenNameLBRACE);
- closingBrace.setWrapPolicy(
- new WrapPolicy(0, openingBraceIndex, this.currentDepth, 1, true, false, -1, false));
+ closingBrace.setWrapPolicy(new WrapPolicy(WrapMode.WHERE_NECESSARY, openingBraceIndex,
+ closingBraceIndex, 0, this.currentDepth, 1, true, false));
}
}
return true;
@@ -425,14 +577,18 @@
@Override
public boolean visit(Assignment node) {
- this.wrapIndexes.add(this.tm.firstIndexIn(node.getRightHandSide(), -1));
+ int wrapIndex = this.tm.firstIndexIn(node.getRightHandSide(), -1);
+ if (this.tm.get(wrapIndex).getLineBreaksBefore() > 0)
+ return true;
int operatorIndex = this.tm.firstIndexBefore(node.getRightHandSide(), -1);
while (this.tm.get(operatorIndex).isComment())
operatorIndex--;
assert node.getOperator().toString().equals(this.tm.toString(operatorIndex));
- this.wrapParentIndex = operatorIndex;
+ this.wrapIndexes.add(wrapIndex);
+ this.secondaryWrapIndexes.add(operatorIndex);
+ this.wrapParentIndex = operatorIndex - 1;
this.wrapGroupEnd = this.tm.lastIndexIn(node.getRightHandSide(), -1);
handleWrap(this.options.alignment_for_assignment);
return true;
@@ -440,12 +596,18 @@
@Override
public boolean visit(VariableDeclarationFragment node) {
- if (node.getInitializer() != null) {
- this.wrapIndexes.add(this.tm.firstIndexIn(node.getInitializer(), -1));
- this.wrapParentIndex = this.tm.firstIndexBefore(node.getInitializer(), TokenNameEQUAL);
+ if (node.getInitializer() == null)
+ return true;
+ int wrapIndex = this.tm.firstIndexIn(node.getInitializer(), -1);
+ if (this.tm.get(wrapIndex).getLineBreaksBefore() > 0)
+ return true;
+ int equalIndex = this.tm.firstIndexBefore(node.getInitializer(), TokenNameEQUAL);
+
+ this.wrapIndexes.add(wrapIndex);
+ this.secondaryWrapIndexes.add(equalIndex);
+ this.wrapParentIndex = equalIndex - 1;
this.wrapGroupEnd = this.tm.lastIndexIn(node.getInitializer(), -1);
handleWrap(this.options.alignment_for_assignment);
- }
return true;
}
@@ -453,45 +615,55 @@
public boolean visit(IfStatement node) {
if (!(node.getThenStatement() instanceof Block)) {
int thenIndex = this.tm.firstIndexIn(node.getThenStatement(), -1);
- if (this.tm.get(thenIndex).getLineBreaksBefore() == 0)
+ if (this.tm.get(thenIndex).getLineBreaksBefore() == 0) {
this.wrapIndexes.add(thenIndex);
+ this.wrapParentIndex = this.tm.firstIndexAfter(node.getExpression(), TokenNameRPAREN);
+ this.wrapGroupEnd = this.tm.lastIndexIn(node.getThenStatement(), -1);
+ handleWrap(this.options.alignment_for_compact_if, node);
+ }
}
Statement elseStatement = node.getElseStatement();
- if (elseStatement != null && !(elseStatement instanceof Block)) {
+ if (elseStatement != null && !(elseStatement instanceof Block) && !(elseStatement instanceof IfStatement)) {
int elseIndex = this.tm.firstIndexIn(elseStatement, -1);
- if (this.tm.get(elseIndex).getLineBreaksBefore() == 0)
+ if (this.tm.get(elseIndex).getLineBreaksBefore() == 0) {
this.wrapIndexes.add(elseIndex);
- }
- if (!this.wrapIndexes.isEmpty()) {
this.wrapParentIndex = this.tm.firstIndexAfter(node.getExpression(), TokenNameRPAREN);
- this.wrapGroupEnd = this.tm.lastIndexIn(node, -1);
+ this.wrapGroupEnd = this.tm.lastIndexIn(elseStatement, -1);
handleWrap(this.options.alignment_for_compact_if, node);
}
+ }
return true;
}
@Override
public boolean visit(TryStatement node) {
- handleArguments(node.resources(), this.options.alignment_for_resources_in_try);
+ prepareElementsList(node.resources(), TokenNameSEMICOLON, TokenNameLPAREN);
+ handleWrap(this.options.alignment_for_resources_in_try);
return true;
}
@Override
public boolean visit(UnionType node) {
List<Type> types = node.types();
- if (this.options.wrap_before_or_operator_multicatch && !types.isEmpty()) {
+ if (types.isEmpty())
+ return true;
+ if (this.options.wrap_before_or_operator_multicatch) {
for (Type type : types) {
if (this.wrapIndexes.isEmpty()) {
this.wrapIndexes.add(this.tm.firstIndexIn(type, -1));
} else {
this.wrapIndexes.add(this.tm.firstIndexBefore(type, TokenNameOR));
+ this.secondaryWrapIndexes.add(this.tm.firstIndexIn(type, -1));
}
}
- this.wrapParentIndex = this.tm.firstIndexBefore(node, TokenNameLPAREN);
+ this.wrapParentIndex = this.tm.firstIndexBefore(node, -1);
+ while (this.tm.get(this.wrapParentIndex).isComment())
+ this.wrapParentIndex--;
this.wrapGroupEnd = this.tm.lastIndexIn(types.get(types.size() - 1), -1);
handleWrap(this.options.alignment_for_union_type_in_multicatch);
} else {
- handleArguments(types, this.options.alignment_for_union_type_in_multicatch);
+ prepareElementsList(types, TokenNameOR, TokenNameLPAREN);
+ handleWrap(this.options.alignment_for_union_type_in_multicatch);
}
return true;
}
@@ -528,16 +700,27 @@
* wrap executor will fix their indentation if necessary.
*/
private void forceContinuousWrapping(ASTNode node, int parentIndex) {
+ int parentIndent = this.tm.get(parentIndex).getIndent();
+ int indentChange = -parentIndent;
+ int lineStart = this.tm.findFirstTokenInLine(parentIndex);
+ for (int i = parentIndex; i >= lineStart; i--) {
+ int align = this.tm.get(i).getAlign();
+ if (align > 0) {
+ indentChange = -2 * parentIndent + align;
+ break;
+ }
+ }
+
+ Token previous = null;
int from = this.tm.firstIndexIn(node, -1);
int to = this.tm.lastIndexIn(node, -1);
- Token wrapParent = this.tm.get(parentIndex);
- Token previous = null;
for (int i = from; i <= to; i++) {
Token token = this.tm.get(i);
if ((token.getLineBreaksBefore() > 0 || (previous != null && previous.getLineBreaksAfter() > 0))
- && token.getWrapPolicy() == null) {
- int indent = (token.getIndent() - wrapParent.getIndent());
- token.setWrapPolicy(new WrapPolicy(indent, parentIndex, true));
+ && (token.getWrapPolicy() == null || token.getWrapPolicy().wrapMode == WrapMode.FORCED)) {
+ int extraIndent = token.getIndent() + indentChange;
+ token.setWrapPolicy(new WrapPolicy(WrapMode.FORCED, parentIndex, extraIndent));
+ token.setIndent(parentIndent + extraIndent);
}
previous = token;
}
@@ -545,25 +728,33 @@
private void handleVariableDeclarations(List<VariableDeclarationFragment> fragments) {
if (fragments.size() > 1) {
- for (int i = 1; i < fragments.size(); i++)
- this.wrapIndexes.add(this.tm.firstIndexIn(fragments.get(i), -1));
this.wrapParentIndex = this.tm.firstIndexIn(fragments.get(0), -1);
- this.wrapGroupEnd = this.tm.lastIndexIn(fragments.get(fragments.size() - 1), -1);
+ prepareElementsList(fragments, TokenNameCOMMA, -1);
+ this.wrapIndexes.remove(0);
handleWrap(this.options.alignment_for_multiple_fields);
}
}
private void handleArguments(List<? extends ASTNode> arguments, int wrappingOption) {
- for (ASTNode argument : arguments)
- this.wrapIndexes.add(this.tm.firstIndexIn(argument, -1));
+ this.wrapPenalties.add(1 / PREFERRED);
+ prepareElementsList(arguments, TokenNameCOMMA, TokenNameLPAREN);
+ handleWrap(wrappingOption);
+ }
+
+ private void prepareElementsList(List<? extends ASTNode> elements, int separatorType, int wrapParentType) {
+ for (int i = 0; i < elements.size(); i++) {
+ ASTNode element = elements.get(i);
+ this.wrapIndexes.add(this.tm.firstIndexIn(element, -1));
+ if (i > 0)
+ this.secondaryWrapIndexes.add(this.tm.firstIndexBefore(element, separatorType));
+ }
// wrapIndexes may have been filled with additional values even if arguments is empty
if (!this.wrapIndexes.isEmpty()) {
Token firstToken = this.tm.get(this.wrapIndexes.get(0));
- this.wrapParentIndex = this.tm.findIndex(firstToken.originalStart - 1, TokenNameLPAREN, false);
- if (!arguments.isEmpty() && this.wrapGroupEnd < 0)
- this.wrapGroupEnd = this.tm.lastIndexIn(arguments.get(arguments.size() - 1), -1);
- assert this.wrapGroupEnd >= 0;
- handleWrap(wrappingOption, 1 / PREFERRED);
+ if (this.wrapParentIndex < 0)
+ this.wrapParentIndex = this.tm.findIndex(firstToken.originalStart - 1, wrapParentType, false);
+ if (!elements.isEmpty() && this.wrapGroupEnd < 0)
+ this.wrapGroupEnd = this.tm.lastIndexIn(elements.get(elements.size() - 1), -1);
}
}
@@ -577,17 +768,23 @@
}
private void handleWrap(int wrappingOption, ASTNode parentNode) {
+ doHandleWrap(wrappingOption, parentNode);
+ this.wrapIndexes.clear();
+ this.secondaryWrapIndexes.clear();
+ this.wrapPenalties.clear();
+ this.wrapParentIndex = this.wrapGroupEnd = -1;
+ }
+
+ private void doHandleWrap(int wrappingOption, ASTNode parentNode) {
if (this.wrapIndexes.isEmpty())
return;
- assert this.wrapParentIndex >= 0;
+ assert this.wrapParentIndex >= 0 && this.wrapParentIndex < this.wrapIndexes.get(0);
+ assert this.wrapGroupEnd >= this.wrapIndexes.get(this.wrapIndexes.size() - 1);
float penalty = this.wrapPenalties.isEmpty() ? 1 : this.wrapPenalties.get(0);
WrapPolicy policy = getWrapPolicy(wrappingOption, penalty, true, parentNode);
- if (policy == null) {
- this.wrapIndexes.clear();
- this.wrapPenalties.clear();
- this.wrapParentIndex = this.wrapGroupEnd = -1;
+ if (policy == null)
return;
- }
+
setTokenWrapPolicy(this.wrapIndexes.get(0), policy, true);
boolean wrapPreceedingComments = !(parentNode instanceof InfixExpression)
@@ -604,20 +801,28 @@
boolean satisfied = false;
for (int index : this.wrapIndexes) {
Token token = this.tm.get(index);
- if (token.getWrapPolicy().isTopPriority()) {
+ if (token.getWrapPolicy().wrapMode == WrapMode.TOP_PRIORITY) {
token.breakBefore();
satisfied = true;
}
}
if (!satisfied) {
- boolean canWrapFirst = (wrappingOption & Alignment.M_NEXT_PER_LINE_SPLIT) != Alignment.M_NEXT_PER_LINE_SPLIT;
+ boolean canWrapFirst = (wrappingOption
+ & Alignment.M_NEXT_PER_LINE_SPLIT) != Alignment.M_NEXT_PER_LINE_SPLIT;
if (canWrapFirst)
this.tm.get(this.wrapIndexes.get(0)).breakBefore();
}
}
- this.wrapIndexes.clear();
- this.wrapPenalties.clear();
- this.wrapParentIndex = this.wrapGroupEnd = -1;
+
+ if (!this.secondaryWrapIndexes.isEmpty()) {
+ int optionNoAlignment = (wrappingOption & ~Alignment.SPLIT_MASK) | Alignment.M_NO_ALIGNMENT;
+ policy = getWrapPolicy(optionNoAlignment, 1, false, parentNode);
+ for (int index : this.secondaryWrapIndexes) {
+ Token token = this.tm.get(index);
+ if (token.getWrapPolicy() == null)
+ token.setWrapPolicy(policy);
+ }
+ }
}
private void setTokenWrapPolicy(int index, WrapPolicy policy, boolean wrapPreceedingComments) {
@@ -635,23 +840,12 @@
Token token = this.tm.get(index);
token.setWrapPolicy(policy);
- if (this.options.join_wrapped_lines
- && (token.tokenType == TokenNameCOMMENT_BLOCK || token.tokenType == TokenNameCOMMENT_JAVADOC)) {
+
+ if (this.options.join_wrapped_lines && token.tokenType == TokenNameCOMMENT_BLOCK) {
// allow wrap preparator to decide if this comment should be wrapped
token.clearLineBreaksBefore();
}
-
- // extend this policy to a token that is in the next line because of comments
- for (int i = index + 1; i < this.tm.size(); i++) {
- Token next = this.tm.get(i);
- WrapPolicy policy2 = next.getWrapPolicy();
- if (policy2 != null && policy2.isForced && policy2.extraIndent == 0) {
- next.setWrapPolicy(policy);
- } else if (next.tokenType != TokenNameCOMMENT_LINE && next.tokenType != TokenNameCOMMENT_BLOCK) {
- break;
}
- }
- }
private WrapPolicy getWrapPolicy(int wrappingOption, float penaltyMultiplier, boolean isFirst, ASTNode parentNode) {
assert this.wrapParentIndex >= 0 && this.wrapGroupEnd >= 0;
@@ -673,10 +867,12 @@
extraIndent = this.options.continuation_indentation_for_array_initializer;
}
+ WrapMode wrapMode = WrapMode.WHERE_NECESSARY;
boolean isTopPriority = false;
switch (wrappingOption & Alignment.SPLIT_MASK) {
case Alignment.M_NO_ALIGNMENT:
- return null;
+ wrapMode = WrapMode.DISABLED;
+ break;
case Alignment.M_COMPACT_FIRST_BREAK_SPLIT:
isTopPriority = isFirst;
break;
@@ -695,16 +891,18 @@
if (isAlreadyWrapped)
isTopPriority = false; // to avoid triggering top priority wrapping
- int topPriorityGroupEnd = isTopPriority ? this.wrapGroupEnd : -1;
+ if (isTopPriority)
+ wrapMode = WrapMode.TOP_PRIORITY;
extraIndent *= this.options.indentation_size;
- return new WrapPolicy(extraIndent, this.wrapParentIndex, this.currentDepth, penaltyMultiplier, isFirst,
- indentOnColumn, topPriorityGroupEnd, false);
+ return new WrapPolicy(wrapMode, this.wrapParentIndex, this.wrapGroupEnd, extraIndent, this.currentDepth,
+ penaltyMultiplier, isFirst, indentOnColumn);
}
- public void finishUp(ASTNode astRoot) {
+ public void finishUp(ASTNode astRoot, IRegion[] regions) {
preserveExistingLineBreaks();
+ if (regions != null)
+ applyBreaksOutsideRegions(regions);
new WrapExecutor(this.tm, this.options).executeWraps();
- if (this.fieldAligner != null)
this.fieldAligner.alignComments();
wrapComments();
fixEnumConstantIndents(astRoot);
@@ -722,45 +920,26 @@
@Override
protected boolean token(Token token, int index) {
- int lineBreaks = getLineBreaksBetween(getPrevious(), token);
- if (index > WrapPreparator.this.importsStart && index < WrapPreparator.this.importsEnd) {
- lineBreaks = lineBreaks > 1 ? (this.options2.blank_lines_between_import_groups + 1) : 0;
- } else {
- lineBreaks = Math.min(lineBreaks, this.options2.number_of_empty_lines_to_preserve + 1);
- }
+ boolean isBetweenImports = index > WrapPreparator.this.importsStart
+ && index < WrapPreparator.this.importsEnd;
+ int lineBreaks = getLineBreaksToPreserve(getPrevious(), token, isBetweenImports);
if (lineBreaks <= getLineBreaksBefore())
return true;
- if (!this.options2.join_wrapped_lines && token.isWrappable() && lineBreaks == 1) {
+ if (lineBreaks == 1) {
+ if ((!this.options2.join_wrapped_lines && token.isWrappable()) || index == 0)
token.breakBefore();
} else if (lineBreaks > 1) {
- if (index == 0)
- lineBreaks--;
token.putLineBreaksBefore(lineBreaks);
}
return true;
}
- private int getLineBreaksBetween(Token token1, Token token2) {
- if (token1 != null) {
- List<Token> structure1 = token1.getInternalStructure();
- if (structure1 != null && !structure1.isEmpty())
- token1 = structure1.get(structure1.size() - 1);
- }
- List<Token> structure2 = token2.getInternalStructure();
- if (structure2 != null && !structure2.isEmpty())
- token2 = structure2.get(0);
- int lineBreaks = WrapPreparator.this.tm.countLineBreaksBetween(token1, token2);
- if (token1 == null)
- lineBreaks++;
- return lineBreaks;
- }
});
Token last = this.tm.get(this.tm.size() - 1);
last.clearLineBreaksAfter();
- int endingBreaks = this.tm.countLineBreaksBetween(last, null);
- endingBreaks = Math.min(endingBreaks, this.options.number_of_empty_lines_to_preserve);
+ int endingBreaks = getLineBreaksToPreserve(last, null, false);
if (endingBreaks > 0) {
last.putLineBreaksAfter(endingBreaks);
} else if ((this.kind & CodeFormatter.K_COMPILATION_UNIT) != 0
@@ -769,6 +948,53 @@
}
}
+ int getLineBreaksToPreserve(Token token1, Token token2, boolean isBetweenImports) {
+ if (token1 != null) {
+ List<Token> structure = token1.getInternalStructure();
+ if (structure != null && !structure.isEmpty())
+ token1 = structure.get(structure.size() - 1);
+ }
+ if (token2 != null) {
+ List<Token> structure = token2.getInternalStructure();
+ if (structure != null && !structure.isEmpty())
+ token2 = structure.get(0);
+ }
+ int lineBreaks = WrapPreparator.this.tm.countLineBreaksBetween(token1, token2);
+ if (isBetweenImports)
+ return lineBreaks > 1 ? (this.options.blank_lines_between_import_groups + 1) : 0;
+
+ int toPreserve = this.options.number_of_empty_lines_to_preserve;
+ if (token1 != null && token2 != null)
+ toPreserve++; // n empty lines = n+1 line breaks, except for file start and end
+ if (token1 != null && token1.tokenType == Token.TokenNameEMPTY_LINE)
+ toPreserve--;
+ return Math.min(lineBreaks, toPreserve);
+ }
+
+ private void applyBreaksOutsideRegions(IRegion[] regions) {
+ String source = this.tm.getSource();
+ int previousRegionEnd = 0;
+ for (IRegion region : regions) {
+ int index = this.tm.findIndex(previousRegionEnd, -1, true);
+ Token token = this.tm.get(index);
+ if (this.tm.countLineBreaksBetween(source, previousRegionEnd,
+ Math.min(token.originalStart, region.getOffset())) > 0)
+ token.breakBefore();
+ for (index++; index < this.tm.size(); index++) {
+ Token next = this.tm.get(index);
+ if (next.originalStart > region.getOffset()) {
+ if (this.tm.countLineBreaksBetween(source, token.originalEnd, region.getOffset()) > 0)
+ next.breakBefore();
+ break;
+ }
+ if (this.tm.countLineBreaksBetween(token, next) > 0)
+ next.breakBefore();
+ token = next;
+ }
+ previousRegionEnd = region.getOffset() + region.getLength() - 1;
+ }
+ }
+
private void wrapComments() {
CommentWrapExecutor commentWrapper = new CommentWrapExecutor(this.tm, this.options);
boolean isNLSTagInLine = false;
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/util/ExternalAnnotationUtil.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/util/ExternalAnnotationUtil.java
index fdc1e21..2ecd344 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/util/ExternalAnnotationUtil.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/util/ExternalAnnotationUtil.java
@@ -32,6 +32,7 @@
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.dom.IMethodBinding;
import org.eclipse.jdt.core.dom.ITypeBinding;
import org.eclipse.jdt.internal.compiler.classfmt.ExternalAnnotationProvider;
@@ -368,19 +369,18 @@
signatureToReplace = originalSignature;
break;
case POSITION_RETURN_TYPE:
- assert originalSignature.charAt(0) == '(' : "signature must start with '('"; //$NON-NLS-1$
+ assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$
int close = originalSignature.indexOf(')');
buf.append(originalSignature, 0, close+1);
signatureToReplace = originalSignature.substring(close+1);
break;
default: // parameter
SignatureWrapper wrapper = new SignatureWrapper(originalSignature.toCharArray(), true, true); // may already contain annotations
- wrapper.start = 1;
+ wrapper.start = CharOperation.indexOf('(', wrapper.signature) + 1; // possibly skipping type parameters
for (int i = 0; i < updatePosition; i++)
- wrapper.start = wrapper.computeEnd() + 1;
+ wrapper.start = wrapper.skipAngleContents(wrapper.computeEnd()) + 1;
int start = wrapper.start;
- int end = wrapper.computeEnd();
- end = wrapper.skipAngleContents(end);
+ int end = wrapper.skipAngleContents(wrapper.computeEnd());
buf.append(originalSignature, 0, start);
signatureToReplace = originalSignature.substring(start, end+1);
postfix = originalSignature.substring(end+1, originalSignature.length());
@@ -643,7 +643,7 @@
{
String[] result = new String[4]; // prefix, orig, replacement, postfix
StringBuffer buf;
- assert originalSignature.charAt(0) == '(' : "signature must start with '('"; //$NON-NLS-1$
+ assert originalSignature.charAt(0) == '(' || originalSignature.charAt(0) == '<': "signature must start with '(' or '<'"; //$NON-NLS-1$
int close = originalSignature.indexOf(')');
result[0] = originalSignature.substring(0, close+1);
buf = new StringBuffer();
@@ -675,12 +675,11 @@
String[] result = new String[4]; // prefix, orig, replacement, postfix
StringBuffer buf;
SignatureWrapper wrapper = new SignatureWrapper(originalSignature.toCharArray(), true, true); // may already contain annotations
- wrapper.start = 1;
+ wrapper.start = CharOperation.indexOf('(', wrapper.signature) + 1; // possibly skip type parameters
for (int i = 0; i < paramIdx; i++)
- wrapper.start = wrapper.computeEnd() + 1;
+ wrapper.start = wrapper.skipAngleContents(wrapper.computeEnd()) + 1;
int start = wrapper.start;
- int end = wrapper.computeEnd();
- end = wrapper.skipAngleContents(end);
+ int end = wrapper.skipAngleContents(wrapper.computeEnd());
result[0] = originalSignature.substring(0, start);
buf = new StringBuffer();
result[1] = originalSignature.substring(start, end+1);
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/parser/TypeConverter.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/parser/TypeConverter.java
index 9a6cee6..61d4a55 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/parser/TypeConverter.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/parser/TypeConverter.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2008, 2013 IBM Corporation and others.
+ * Copyright (c) 2008, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -113,7 +113,7 @@
int length = typeName.length;
this.namePos = 0;
- return decodeType(typeName, length, start, end, true);
+ return decodeType2(typeName, length, start, end, true);
}
/*
@@ -126,7 +126,7 @@
int length = typeName.length;
this.namePos = 0;
- return decodeType(typeName, length, start, end, false);
+ return decodeType2(typeName, length, start, end, false);
}
/*
@@ -366,7 +366,7 @@
}
}
- private TypeReference decodeType(char[] typeName, int length, int start, int end, boolean includeGenericsAnyway) {
+ private TypeReference decodeType2(char[] typeName, int length, int start, int end, boolean includeGenericsAnyway) {
int identCount = 1;
int dim = 0;
int nameFragmentStart = this.namePos, nameFragmentEnd = -1;
@@ -388,7 +388,7 @@
}
this.namePos += max;
Wildcard result = new Wildcard(Wildcard.SUPER);
- result.bound = decodeType(typeName, length, start, end, includeGenericsAnyway);
+ result.bound = decodeType2(typeName, length, start, end, includeGenericsAnyway);
result.sourceStart = start;
result.sourceEnd = end;
return result;
@@ -404,7 +404,7 @@
}
this.namePos += max;
Wildcard result = new Wildcard(Wildcard.EXTENDS);
- result.bound = decodeType(typeName, length, start, end, includeGenericsAnyway);
+ result.bound = decodeType2(typeName, length, start, end, includeGenericsAnyway);
result.sourceStart = start;
result.sourceEnd = end;
return result;
@@ -460,6 +460,18 @@
}
this.namePos++;
}
+ return decodeType3(typeName, length, start, end, identCount, dim, nameFragmentStart, nameFragmentEnd,
+ fragments);
+ }
+
+ /*
+ * Method should be inlined.
+ *
+ * Only extracted to work around https://bugs.eclipse.org/471835 :
+ * Random crashes in PhaseIdealLoop::build_loop_late_post when C2 JIT tries to compile TypeConverter::decodeType
+ */
+ private TypeReference decodeType3(char[] typeName, int length, int start, int end, int identCount, int dim,
+ int nameFragmentStart, int nameFragmentEnd, ArrayList fragments) {
if (nameFragmentEnd < 0) nameFragmentEnd = this.namePos-1;
if (fragments == null) { // non parameterized
/* rebuild identifiers and dimensions */
@@ -542,7 +554,7 @@
ArrayList argumentList = new ArrayList(1);
int count = 0;
argumentsLoop: while (this.namePos < length) {
- TypeReference argument = decodeType(typeName, length, start, end, includeGenericsAnyway);
+ TypeReference argument = decodeType2(typeName, length, start, end, includeGenericsAnyway);
count++;
argumentList.add(argument);
if (this.namePos >= length) break argumentsLoop;
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java
index 6941961..d085650 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java
@@ -88,6 +88,13 @@
}
/* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeAnnotationTypeDeclarationHeader()
+ */
+ protected void consumeAnnotationTypeDeclarationHeader() {
+ pushOnCommentsStack(0, this.scanner.commentPtr);
+ super.consumeAnnotationTypeDeclarationHeader();
+ }
+ /* (non-Javadoc)
* @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeClassHeader()
*/
protected void consumeClassHeader() {
@@ -102,6 +109,22 @@
super.consumeEmptyTypeDeclaration();
}
/* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeEnterAnonymousClassBody(boolean)
+ */
+ @Override
+ protected void consumeEnterAnonymousClassBody(boolean qualified) {
+ pushOnCommentsStack(0, this.scanner.commentPtr);
+ super.consumeEnterAnonymousClassBody(qualified);
+ }
+ /* (non-Javadoc)
+ * @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeEnumHeader()
+ */
+ protected void consumeEnumHeader() {
+ pushOnCommentsStack(0, this.scanner.commentPtr);
+ super.consumeEnumHeader();
+ }
+
+ /* (non-Javadoc)
* @see org.eclipse.jdt.internal.compiler.parser.Parser#consumeInterfaceHeader()
*/
protected void consumeInterfaceHeader() {
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java
index a5647e0..f24bba1 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/matching/MatchLocator.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 IBM Corporation and others.
+ * Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@@ -1165,6 +1165,7 @@
this.lookupEnvironment = new LookupEnvironment(this, this.options, problemReporter, this.nameEnvironment);
this.lookupEnvironment.mayTolerateMissingType = true;
this.parser = MatchLocatorParser.createParser(problemReporter, this);
+ this.bindings = new SimpleLookupTable(); // For every LE
// basic parser needs also to be reset as project options may have changed
// see bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=163072
