Upgrade to neon.2 75dbfad0
diff --git a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/BuildJarIndex.java b/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/BuildJarIndex.java
index cd7238a..fcb9685 100644
--- a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/BuildJarIndex.java
+++ b/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/BuildJarIndex.java
@@ -48,7 +48,7 @@
try {
JavaIndexer.generateIndexForJar(this.jarPath, this.indexPath);
} catch (IOException e) {
- throw new BuildException(AntAdapterMessages.getString("buildJarIndex.ioexception.occured", e.getLocalizedMessage())); //$NON-NLS-1$
+ throw new BuildException(AntAdapterMessages.getString("buildJarIndex.ioexception.occured", e.getLocalizedMessage()), e); //$NON-NLS-1$
}
}
diff --git a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/CheckDebugAttributes.java b/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/CheckDebugAttributes.java
index b6617d7..28488d8 100644
--- a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/CheckDebugAttributes.java
+++ b/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/CheckDebugAttributes.java
@@ -60,7 +60,7 @@
try {
jarFile = new ZipFile(this.file);
} catch (ZipException e) {
- throw new BuildException(AntAdapterMessages.getString("checkDebugAttributes.file.argument.must.be.a.classfile.or.a.jarfile")); //$NON-NLS-1$
+ throw new BuildException(AntAdapterMessages.getString("checkDebugAttributes.file.argument.must.be.a.classfile.or.a.jarfile"), e); //$NON-NLS-1$
} finally {
if (jarFile != null) {
jarFile.close();
@@ -78,7 +78,7 @@
getProject().setUserProperty(this.property, "has debug"); //$NON-NLS-1$
}
} catch (IOException e) {
- throw new BuildException(AntAdapterMessages.getString("checkDebugAttributes.ioexception.occured") + this.file); //$NON-NLS-1$
+ throw new BuildException(AntAdapterMessages.getString("checkDebugAttributes.ioexception.occured") + this.file, e); //$NON-NLS-1$
}
}
diff --git a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/JDTCompilerAdapter.java b/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/JDTCompilerAdapter.java
index c2bdf71..507f55d 100644
--- a/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/JDTCompilerAdapter.java
+++ b/org.eclipse.jdt.core/antadapter/org/eclipse/jdt/core/JDTCompilerAdapter.java
@@ -84,7 +84,7 @@
}
return resultValue;
} catch (ClassNotFoundException cnfe) {
- throw new BuildException(AntAdapterMessages.getString("ant.jdtadapter.error.cannotFindJDTCompiler")); //$NON-NLS-1$
+ throw new BuildException(AntAdapterMessages.getString("ant.jdtadapter.error.cannotFindJDTCompiler"), cnfe); //$NON-NLS-1$
} catch (Exception ex) {
throw new BuildException(ex);
}
diff --git a/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java b/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
index 6f5c2a5..b0ac625 100644
--- a/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
+++ b/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/model/TypesImpl.java
@@ -8,6 +8,7 @@
* Contributors:
* Walter Harley - initial API and implementation
* IBM Corporation - fix for 342598, 382590
+ * Jean-Marie Henaff <jmhenaff@google.com> (Google) - Bug 481555
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.apt.model;
@@ -74,62 +75,124 @@
}
@Override
- public TypeMirror asMemberOf(DeclaredType containing, Element element) {
-// throw new UnsupportedOperationException("NYI: TypesImpl.asMemberOf(" + containing + ", " + element + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
- ElementImpl elementImpl = (ElementImpl) element;
- DeclaredTypeImpl declaredTypeImpl = (DeclaredTypeImpl) containing;
- ReferenceBinding referenceBinding = (ReferenceBinding) declaredTypeImpl._binding;
- switch(element.getKind()) {
- case CONSTRUCTOR :
- case METHOD :
- MethodBinding methodBinding = (MethodBinding) elementImpl._binding;
- while (referenceBinding != null) {
- for (MethodBinding method : referenceBinding.methods()) {
- if (CharOperation.equals(method.selector, methodBinding.selector) &&
- (method.original() == methodBinding || method.areParameterErasuresEqual(methodBinding))) {
- return this._env.getFactory().newTypeMirror(method);
- }
- }
- referenceBinding = referenceBinding.superclass();
- }
- break;
- case FIELD :
- case ENUM_CONSTANT:
- FieldBinding fieldBinding = (FieldBinding) elementImpl._binding;
- while (referenceBinding != null) {
- for (FieldBinding field : referenceBinding.fields()) {
- if (CharOperation.equals(field.name, fieldBinding.name)) {
- return this._env.getFactory().newTypeMirror(field);
- }
- }
- referenceBinding = referenceBinding.superclass();
- }
- break;
- case ENUM :
- case ANNOTATION_TYPE :
- case INTERFACE :
- case CLASS :
- ReferenceBinding elementBinding = (ReferenceBinding) elementImpl._binding;
- while (referenceBinding != null) {
- // If referenceBinding is a ParameterizedTypeBinding, this will return only ParameterizedTypeBindings
- // for member types, even if the member happens to be a static nested class. That's probably a bug;
- // static nested classes are not parameterized by their outer class.
- for (ReferenceBinding memberReferenceBinding : referenceBinding.memberTypes()) {
- if (CharOperation.equals(elementBinding.compoundName, memberReferenceBinding.compoundName)) {
- return this._env.getFactory().newTypeMirror(memberReferenceBinding);
- }
- }
- referenceBinding = referenceBinding.superclass();
- }
- break;
- default:
- throw new IllegalArgumentException("element " + element + //$NON-NLS-1$
- " has unrecognized element kind " + element.getKind()); //$NON-NLS-1$
- }
- throw new IllegalArgumentException("element " + element + //$NON-NLS-1$
- " is not a member of the containing type " + containing + //$NON-NLS-1$
- " nor any of its superclasses"); //$NON-NLS-1$
- }
+ public TypeMirror asMemberOf(DeclaredType containing, Element element) {
+ // throw new UnsupportedOperationException("NYI: TypesImpl.asMemberOf("
+ // + containing + ", " + element + ")"); //$NON-NLS-1$ //$NON-NLS-2$
+ // //$NON-NLS-3$
+ ElementImpl elementImpl = (ElementImpl) element;
+ DeclaredTypeImpl declaredTypeImpl = (DeclaredTypeImpl) containing;
+ ReferenceBinding referenceBinding = (ReferenceBinding) declaredTypeImpl._binding;
+ TypeMirror typeMirror;
+
+ switch (element.getKind()) {
+ case CONSTRUCTOR:
+ case METHOD:
+ typeMirror = findMemberInHierarchy(referenceBinding, elementImpl._binding, new MemberInTypeFinder() {
+ @Override
+ public TypeMirror find(ReferenceBinding typeBinding, Binding memberBinding) {
+ MethodBinding methodBinding = ((MethodBinding) memberBinding);
+ for (MethodBinding method : typeBinding.methods()) {
+ if (CharOperation.equals(method.selector, methodBinding.selector)
+ && (method.original() == methodBinding
+ || method.areParameterErasuresEqual(methodBinding))) {
+ return TypesImpl.this._env.getFactory().newTypeMirror(method);
+ }
+ }
+ return null;
+ }
+ });
+
+ if (typeMirror != null) {
+ return typeMirror;
+ }
+ break;
+ case FIELD:
+ case ENUM_CONSTANT:
+ typeMirror = findMemberInHierarchy(referenceBinding, elementImpl._binding, new MemberInTypeFinder() {
+ @Override
+ public TypeMirror find(ReferenceBinding typeBinding, Binding memberBinding) {
+ FieldBinding fieldBinding = (FieldBinding) memberBinding;
+ for (FieldBinding field : typeBinding.fields()) {
+ if (CharOperation.equals(field.name, fieldBinding.name)) {
+ return TypesImpl.this._env.getFactory().newTypeMirror(field);
+ }
+ }
+ return null;
+ }
+ });
+
+ if (typeMirror != null) {
+ return typeMirror;
+ }
+ break;
+ case ENUM:
+ case ANNOTATION_TYPE:
+ case INTERFACE:
+ case CLASS:
+
+ typeMirror = findMemberInHierarchy(referenceBinding, elementImpl._binding, new MemberInTypeFinder() {
+ @Override
+ public TypeMirror find(ReferenceBinding typeBinding, Binding memberBinding) {
+ ReferenceBinding elementBinding = (ReferenceBinding) memberBinding;
+ // If referenceBinding is a ParameterizedTypeBinding, this
+ // will return only ParameterizedTypeBindings
+ // for member types, even if the member happens to be a
+ // static nested class. That's probably a bug;
+ // static nested classes are not parameterized by their
+ // outer class.
+ for (ReferenceBinding memberReferenceBinding : typeBinding.memberTypes()) {
+ if (CharOperation.equals(elementBinding.compoundName, memberReferenceBinding.compoundName)) {
+ return TypesImpl.this._env.getFactory().newTypeMirror(memberReferenceBinding);
+ }
+ }
+ return null;
+ }
+ });
+
+ if (typeMirror != null) {
+ return typeMirror;
+ }
+ break;
+ default:
+ throw new IllegalArgumentException("element " + element + //$NON-NLS-1$
+ " has unrecognized element kind " + element.getKind()); //$NON-NLS-1$
+ }
+ throw new IllegalArgumentException("element " + element + //$NON-NLS-1$
+ " is not a member of the containing type " + containing + //$NON-NLS-1$
+ " nor any of its superclasses"); //$NON-NLS-1$
+ }
+
+ private static interface MemberInTypeFinder {
+ TypeMirror find(ReferenceBinding typeBinding, Binding memberBinding);
+ }
+
+ private TypeMirror findMemberInHierarchy(ReferenceBinding typeBinding, Binding memberBinding,
+ MemberInTypeFinder finder) {
+ TypeMirror result = null;
+
+ if (typeBinding == null) {
+ return null;
+ }
+
+ result = finder.find(typeBinding, memberBinding);
+ if (result != null) {
+ return result;
+ }
+
+ result = findMemberInHierarchy(typeBinding.superclass(), memberBinding, finder);
+ if (result != null) {
+ return result;
+ }
+
+ for (ReferenceBinding superInterface : typeBinding.superInterfaces()) {
+ result = findMemberInHierarchy(superInterface, memberBinding, finder);
+ if (result != null) {
+ return result;
+ }
+ }
+
+ return null;
+ }
@Override
public TypeElement boxedClass(PrimitiveType p) {
diff --git a/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/util/EclipseFileManager.java b/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/util/EclipseFileManager.java
index 96bd353..2319696 100644
--- a/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/util/EclipseFileManager.java
+++ b/org.eclipse.jdt.core/apt/org/eclipse/jdt/internal/compiler/apt/util/EclipseFileManager.java
@@ -452,7 +452,7 @@
}
uri2 = new URI(uri.getScheme(), uri.getHost(), path, uri.getFragment());
} catch (URISyntaxException e) {
- throw new IllegalArgumentException("invalid sibling");//$NON-NLS-1$
+ throw new IllegalArgumentException("invalid sibling", e);//$NON-NLS-1$
}
return new EclipseFileObject(className, uri2, kind, this.charset);
} else {
diff --git a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
index e1d1283..2bfd704 100644
--- a/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
+++ b/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java
@@ -1223,9 +1223,9 @@
this.log.println("# " + dateFormat.format(date));//$NON-NLS-1$
}
} catch (FileNotFoundException e) {
- throw new IllegalArgumentException(this.main.bind("configure.cannotOpenLog", logFileName)); //$NON-NLS-1$
+ throw new IllegalArgumentException(this.main.bind("configure.cannotOpenLog", logFileName), e); //$NON-NLS-1$
} catch (UnsupportedEncodingException e) {
- throw new IllegalArgumentException(this.main.bind("configure.cannotOpenLogInvalidEncoding", logFileName)); //$NON-NLS-1$
+ throw new IllegalArgumentException(this.main.bind("configure.cannotOpenLogInvalidEncoding", logFileName), e); //$NON-NLS-1$
}
}
private void startLoggingExtraProblems(int count) {
@@ -1955,7 +1955,7 @@
new InputStreamReader(new ByteArrayInputStream(new byte[0]), customEncoding);
} catch (UnsupportedEncodingException e) {
throw new IllegalArgumentException(
- this.bind("configure.unsupportedEncoding", customEncoding)); //$NON-NLS-1$
+ this.bind("configure.unsupportedEncoding", customEncoding), e); //$NON-NLS-1$
}
}
currentArg = currentArg.substring(0, encodingStart - 1);
@@ -2547,7 +2547,7 @@
throw new IllegalArgumentException(this.bind("configure.repetition", currentArg)); //$NON-NLS-1$
}
} catch (NumberFormatException e) {
- throw new IllegalArgumentException(this.bind("configure.repetition", currentArg)); //$NON-NLS-1$
+ throw new IllegalArgumentException(this.bind("configure.repetition", currentArg), e); //$NON-NLS-1$
}
mode = DEFAULT;
continue;
@@ -2559,7 +2559,7 @@
}
this.options.put(CompilerOptions.OPTION_MaxProblemPerUnit, currentArg);
} catch (NumberFormatException e) {
- throw new IllegalArgumentException(this.bind("configure.maxProblems", currentArg)); //$NON-NLS-1$
+ throw new IllegalArgumentException(this.bind("configure.maxProblems", currentArg), e); //$NON-NLS-1$
}
mode = DEFAULT;
continue;
@@ -2609,7 +2609,7 @@
new InputStreamReader(new ByteArrayInputStream(new byte[0]), currentArg);
} catch (UnsupportedEncodingException e) {
throw new IllegalArgumentException(
- this.bind("configure.unsupportedEncoding", currentArg)); //$NON-NLS-1$
+ this.bind("configure.unsupportedEncoding", currentArg), e); //$NON-NLS-1$
}
specifiedEncodings.add(currentArg);
this.options.put(CompilerOptions.OPTION_Encoding, currentArg);
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CharOperation.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CharOperation.java
index 7eafeee..23b3817 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CharOperation.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/CharOperation.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
@@ -9,9 +9,12 @@
* IBM Corporation - initial API and implementation
* Luiz-Otavio Zorzella <zorzella at gmail dot com> - Improve CamelCase algorithm
* Gábor Kövesdán - Contribution for Bug 350000 - [content assist] Include non-prefix matches in auto-complete suggestions
+ * Stefan Xenos <sxenos@gmail.com> (Google) - Bug 501283 - Lots of hash collisions during indexing
*******************************************************************************/
package org.eclipse.jdt.core.compiler;
+import java.util.Arrays;
+
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
/**
@@ -2281,19 +2284,9 @@
*
* @param array the array for which a hashcode is required
* @return the hashcode
- * @throws NullPointerException if array is null
*/
public static final int hashCode(char[] array) {
- int length = array.length;
- int hash = length == 0 ? 31 : array[0];
- if (length < 8) {
- for (int i = length; --i > 0;)
- hash = (hash * 31) + array[i];
- } else {
- // 8 characters is enough to compute a decent hash code, don't waste time examining every character
- for (int i = length - 1, last = i > 16 ? i - 16 : 0; i > last; i -= 2)
- hash = (hash * 31) + array[i];
- }
+ int hash = Arrays.hashCode(array);
return hash & 0x7FFFFFFF;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java
index 671edcf..c0d8ebd 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java
@@ -1894,6 +1894,12 @@
int IllegalDefaultModifierSpecification = MethodRelated + 1058;
/** @since 3.13 */
int CannotInferInvocationType = TypeRelated + 1059;
+
+ /** @since 3.13 */
+ int TypeAnnotationAtQualifiedName = Internal + Syntax + 1060;
+
+ /** @since 3.13 */
+ int NullAnnotationAtQualifyingType = Internal + Syntax + 1061;
/** @since 3.10 */
int GenericInferenceError = 1100; // FIXME: This is just a stop-gap measure, be more specific via https://bugs.eclipse.org/404675
@@ -1901,4 +1907,6 @@
/** @deprecated - problem is no longer generated (implementation issue has been resolved)
* @since 3.10 */
int LambdaShapeComputationError = 1101;
+ /** @since 3.13 */
+ int ProblemNotAnalysed = 1102;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
index 12639ff..5d4fb85 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java
@@ -695,8 +695,11 @@
} else {
updatedArgumentType = argument.resolveType(scope);
}
- if (updatedArgumentType != null && updatedArgumentType.kind() != Binding.POLY_TYPE)
+ if (updatedArgumentType != null && updatedArgumentType.kind() != Binding.POLY_TYPE) {
argumentTypes[i] = updatedArgumentType;
+ if (candidateMethod.isPolymorphic())
+ candidateMethod.parameters[i] = updatedArgumentType;
+ }
}
}
}
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 9606e2b..9f06279 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
@@ -644,7 +644,7 @@
// no need to check annotation usage if missing
return;
}
- if (! isAnnotationTargetAllowed(repeatingAnnotation, scope, containerAnnotationType, repeatingAnnotation.recipient.kind())) {
+ if (isAnnotationTargetAllowed(repeatingAnnotation, scope, containerAnnotationType, repeatingAnnotation.recipient.kind()) != AnnotationTargetAllowed.YES) {
scope.problemReporter().disallowedTargetForContainerAnnotation(repeatingAnnotation, containerAnnotationType);
}
}
@@ -961,63 +961,71 @@
return this.resolvedType;
}
- private static boolean isAnnotationTargetAllowed(Binding recipient, BlockScope scope, TypeBinding annotationType, int kind, long metaTagBits) {
+ public enum AnnotationTargetAllowed {
+ YES, TYPE_ANNOTATION_ON_QUALIFIED_NAME, NO;
+ }
+
+ private static AnnotationTargetAllowed isAnnotationTargetAllowed(Binding recipient, BlockScope scope, TypeBinding annotationType, int kind, long metaTagBits) {
switch (kind) {
case Binding.PACKAGE :
if ((metaTagBits & TagBits.AnnotationForPackage) != 0)
- return true;
+ return AnnotationTargetAllowed.YES;
else if (scope.compilerOptions().sourceLevel <= ClassFileConstants.JDK1_6) {
SourceTypeBinding sourceType = (SourceTypeBinding) recipient;
if (CharOperation.equals(sourceType.sourceName, TypeConstants.PACKAGE_INFO_NAME))
- return true;
+ return AnnotationTargetAllowed.YES;
}
break;
case Binding.TYPE_USE :
if ((metaTagBits & TagBits.AnnotationForTypeUse) != 0) {
// jsr 308
- return true;
+ return AnnotationTargetAllowed.YES;
}
if (scope.compilerOptions().sourceLevel < ClassFileConstants.JDK1_8) {
// already reported as syntax error; don't report secondary problems
- return true;
+ return AnnotationTargetAllowed.YES;
}
break;
case Binding.TYPE :
case Binding.GENERIC_TYPE :
if (((ReferenceBinding)recipient).isAnnotationType()) {
if ((metaTagBits & (TagBits.AnnotationForAnnotationType | TagBits.AnnotationForType | TagBits.AnnotationForTypeUse)) != 0)
- return true;
+ return AnnotationTargetAllowed.YES;
} else if ((metaTagBits & (TagBits.AnnotationForType | TagBits.AnnotationForTypeUse)) != 0) {
- return true;
+ return AnnotationTargetAllowed.YES;
} else if ((metaTagBits & TagBits.AnnotationForPackage) != 0) {
if (CharOperation.equals(((ReferenceBinding) recipient).sourceName, TypeConstants.PACKAGE_INFO_NAME))
- return true;
+ return AnnotationTargetAllowed.YES;
}
break;
case Binding.METHOD :
MethodBinding methodBinding = (MethodBinding) recipient;
if (methodBinding.isConstructor()) {
if ((metaTagBits & (TagBits.AnnotationForConstructor | TagBits.AnnotationForTypeUse)) != 0)
- return true;
+ return AnnotationTargetAllowed.YES;
} else if ((metaTagBits & TagBits.AnnotationForMethod) != 0) {
- return true;
+ return AnnotationTargetAllowed.YES;
} else if ((metaTagBits & TagBits.AnnotationForTypeUse) != 0) {
SourceTypeBinding sourceType = (SourceTypeBinding) methodBinding.declaringClass;
MethodDeclaration methodDecl = (MethodDeclaration) sourceType.scope.referenceContext.declarationOf(methodBinding);
if (isTypeUseCompatible(methodDecl.returnType, scope)) {
- return true;
+ return AnnotationTargetAllowed.YES;
+ } else {
+ return AnnotationTargetAllowed.TYPE_ANNOTATION_ON_QUALIFIED_NAME;
}
}
break;
case Binding.FIELD :
if ((metaTagBits & TagBits.AnnotationForField) != 0) {
- return true;
+ return AnnotationTargetAllowed.YES;
} else if ((metaTagBits & TagBits.AnnotationForTypeUse) != 0) {
FieldBinding sourceField = (FieldBinding) recipient;
SourceTypeBinding sourceType = (SourceTypeBinding) sourceField.declaringClass;
FieldDeclaration fieldDeclaration = sourceType.scope.referenceContext.declarationOf(sourceField);
if (isTypeUseCompatible(fieldDeclaration.type, scope)) {
- return true;
+ return AnnotationTargetAllowed.YES;
+ } else {
+ return AnnotationTargetAllowed.TYPE_ANNOTATION_ON_QUALIFIED_NAME;
}
}
break;
@@ -1025,27 +1033,31 @@
LocalVariableBinding localVariableBinding = (LocalVariableBinding) recipient;
if ((localVariableBinding.tagBits & TagBits.IsArgument) != 0) {
if ((metaTagBits & TagBits.AnnotationForParameter) != 0) {
- return true;
+ return AnnotationTargetAllowed.YES;
} else if ((metaTagBits & TagBits.AnnotationForTypeUse) != 0) {
if (isTypeUseCompatible(localVariableBinding.declaration.type, scope)) {
- return true;
+ return AnnotationTargetAllowed.YES;
+ } else {
+ return AnnotationTargetAllowed.TYPE_ANNOTATION_ON_QUALIFIED_NAME;
}
}
} else if ((annotationType.tagBits & TagBits.AnnotationForLocalVariable) != 0) {
- return true;
+ return AnnotationTargetAllowed.YES;
} else if ((metaTagBits & TagBits.AnnotationForTypeUse) != 0) {
if (isTypeUseCompatible(localVariableBinding.declaration.type, scope)) {
- return true;
+ return AnnotationTargetAllowed.YES;
+ } else {
+ return AnnotationTargetAllowed.TYPE_ANNOTATION_ON_QUALIFIED_NAME;
}
}
break;
case Binding.TYPE_PARAMETER : // jsr308
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391196
if ((metaTagBits & (TagBits.AnnotationForTypeParameter | TagBits.AnnotationForTypeUse)) != 0) {
- return true;
+ return AnnotationTargetAllowed.YES;
}
}
- return false;
+ return AnnotationTargetAllowed.NO;
}
public static boolean isAnnotationTargetAllowed(BlockScope scope, TypeBinding annotationType, Binding recipient) {
@@ -1053,10 +1065,10 @@
if ((metaTagBits & TagBits.AnnotationTargetMASK) == 0) {
return true;
}
- return isAnnotationTargetAllowed(recipient, scope, annotationType, recipient.kind(), metaTagBits);
+ return isAnnotationTargetAllowed(recipient, scope, annotationType, recipient.kind(), metaTagBits)==AnnotationTargetAllowed.YES;
}
- static boolean isAnnotationTargetAllowed(Annotation annotation, BlockScope scope, TypeBinding annotationType, int kind) {
+ static AnnotationTargetAllowed isAnnotationTargetAllowed(Annotation annotation, BlockScope scope, TypeBinding annotationType, int kind) {
long metaTagBits = annotationType.getAnnotationTagBits(); // could be forward reference
if ((metaTagBits & TagBits.AnnotationTargetMASK) == 0) {
@@ -1064,7 +1076,7 @@
if (kind == Binding.TYPE_PARAMETER || kind == Binding.TYPE_USE) {
scope.problemReporter().explitAnnotationTargetRequired(annotation);
}
- return true;
+ return AnnotationTargetAllowed.YES;
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391201
@@ -1091,8 +1103,13 @@
// no need to check annotation usage if missing
return;
}
- if (! isAnnotationTargetAllowed(annotation, scope, annotationType, kind)) {
+ AnnotationTargetAllowed annotationTargetAllowed = isAnnotationTargetAllowed(annotation, scope, annotationType, kind);
+ if (annotationTargetAllowed != AnnotationTargetAllowed.YES) {
+ if(annotationTargetAllowed == AnnotationTargetAllowed.TYPE_ANNOTATION_ON_QUALIFIED_NAME) {
+ scope.problemReporter().typeAnnotationAtQualifiedName(annotation);
+ } else {
scope.problemReporter().disallowedTargetForAnnotation(annotation);
+ }
if (recipient instanceof TypeBinding)
((TypeBinding)recipient).tagBits &= ~tagBitsToRevert;
}
@@ -1161,7 +1178,7 @@
continue nextAnnotation;
} else {
if (annotation.hasNullBit(TypeIds.BitNonNullAnnotation|TypeIds.BitNullableAnnotation)) {
- scope.problemReporter().nullAnnotationUnsupportedLocation(annotation);
+ scope.problemReporter().nullAnnotationAtQualifyingType(annotation);
continue nextAnnotation;
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
index 00b8bea..1c7dafb 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java
@@ -267,6 +267,9 @@
}
public boolean checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, int ttlForFieldCheck) {
+ if((this.resolvedType.tagBits & TagBits.AnnotationNonNull) != 0) {
+ return true;
+ }
checkNPEbyUnboxing(scope, flowContext, flowInfo);
return this.expression.checkNPE(scope, flowContext, flowInfo, ttlForFieldCheck);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java
index 895ea19..acb079b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/CompilationUnitDeclaration.java
@@ -299,22 +299,28 @@
Constant cst = inits[iToken].constant;
if (cst != Constant.NotAConstant && cst.typeID() == TypeIds.T_JavaLangString) {
IrritantSet tokenIrritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
- if (tokenIrritants != null
- && !tokenIrritants.areAllSet() // no complaint against @SuppressWarnings("all")
- && options.isAnyEnabled(tokenIrritants) // if irritant is effectively enabled
- && (foundIrritants[iSuppress] == null || !foundIrritants[iSuppress].isAnySet(tokenIrritants))) { // if irritant had no matching problem
- if (unusedWarningTokenIsWarning) {
- int start = value.sourceStart, end = value.sourceEnd;
- nextSuppress: for (int jSuppress = iSuppress - 1; jSuppress >= 0; jSuppress--) {
- long position = this.suppressWarningScopePositions[jSuppress];
- int startSuppress = (int) (position >>> 32);
- int endSuppress = (int) position;
- if (start < startSuppress) continue nextSuppress;
- if (end > endSuppress) continue nextSuppress;
- if (this.suppressWarningIrritants[jSuppress].areAllSet()) break pairLoop; // suppress all?
+ if (tokenIrritants != null) {
+ if (!tokenIrritants.areAllSet() // no complaint against @SuppressWarnings("all")
+ && (foundIrritants[iSuppress] == null || !foundIrritants[iSuppress].isAnySet(tokenIrritants))) { // if irritant had no matching problem
+ if (unusedWarningTokenIsWarning) {
+ int start = value.sourceStart, end = value.sourceEnd;
+ nextSuppress: for (int jSuppress = iSuppress - 1; jSuppress >= 0; jSuppress--) {
+ long position = this.suppressWarningScopePositions[jSuppress];
+ int startSuppress = (int) (position >>> 32);
+ int endSuppress = (int) position;
+ if (start < startSuppress) continue nextSuppress;
+ if (end > endSuppress) continue nextSuppress;
+ if (this.suppressWarningIrritants[jSuppress].areAllSet()) break pairLoop; // suppress all?
+ }
+ }
+ int id = options.getIgnoredIrritant(tokenIrritants);
+ if (id > 0) {
+ String key = CompilerOptions.optionKeyFromIrritant(id);
+ this.scope.problemReporter().problemNotAnalysed(inits[iToken], key);
+ } else {
+ this.scope.problemReporter().unusedWarningToken(inits[iToken]);
}
}
- this.scope.problemReporter().unusedWarningToken(inits[iToken]);
}
}
}
@@ -323,22 +329,28 @@
Constant cst = value.constant;
if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
IrritantSet tokenIrritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
- if (tokenIrritants != null
- && !tokenIrritants.areAllSet() // no complaint against @SuppressWarnings("all")
- && options.isAnyEnabled(tokenIrritants) // if irritant is effectively enabled
- && (foundIrritants[iSuppress] == null || !foundIrritants[iSuppress].isAnySet(tokenIrritants))) { // if irritant had no matching problem
- if (unusedWarningTokenIsWarning) {
- int start = value.sourceStart, end = value.sourceEnd;
- nextSuppress: for (int jSuppress = iSuppress - 1; jSuppress >= 0; jSuppress--) {
- long position = this.suppressWarningScopePositions[jSuppress];
- int startSuppress = (int) (position >>> 32);
- int endSuppress = (int) position;
- if (start < startSuppress) continue nextSuppress;
- if (end > endSuppress) continue nextSuppress;
- if (this.suppressWarningIrritants[jSuppress].areAllSet()) break pairLoop; // suppress all?
+ if (tokenIrritants != null) {
+ if (!tokenIrritants.areAllSet() // no complaint against @SuppressWarnings("all")
+ && (foundIrritants[iSuppress] == null || !foundIrritants[iSuppress].isAnySet(tokenIrritants))) { // if irritant had no matching problem
+ if (unusedWarningTokenIsWarning) {
+ int start = value.sourceStart, end = value.sourceEnd;
+ nextSuppress: for (int jSuppress = iSuppress - 1; jSuppress >= 0; jSuppress--) {
+ long position = this.suppressWarningScopePositions[jSuppress];
+ int startSuppress = (int) (position >>> 32);
+ int endSuppress = (int) position;
+ if (start < startSuppress) continue nextSuppress;
+ if (end > endSuppress) continue nextSuppress;
+ if (this.suppressWarningIrritants[jSuppress].areAllSet()) break pairLoop; // suppress all?
+ }
+ }
+ int id = options.getIgnoredIrritant(tokenIrritants);
+ if (id > 0) {
+ String key = CompilerOptions.optionKeyFromIrritant(id);
+ this.scope.problemReporter().problemNotAnalysed(value, key);
+ } else {
+ this.scope.problemReporter().unusedWarningToken(value);
}
}
- this.scope.problemReporter().unusedWarningToken(value);
}
}
}
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 ff0850e..789c72d 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
@@ -670,13 +670,13 @@
// Answer the signature return type, answers PolyTypeBinding if a poly expression and there is no target type
// Base type promotion
if (this.constant != Constant.NotAConstant) {
- this.constant = Constant.NotAConstant;
- long sourceLevel = scope.compilerOptions().sourceLevel;
- boolean receiverCast = false;
- if (this.receiver instanceof CastExpression) {
- this.receiver.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
- receiverCast = true;
- }
+ this.constant = Constant.NotAConstant;
+ long sourceLevel = scope.compilerOptions().sourceLevel;
+ boolean receiverCast = false;
+ if (this.receiver instanceof CastExpression) {
+ this.receiver.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
+ receiverCast = true;
+ }
// AspectJ Extension: commenting this out for now. An InterTypeScope has been observed
// to have an already resolved receiver
// if (this.receiver.resolvedType != null)
@@ -689,8 +689,11 @@
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
- if (TypeBinding.equalsEquals(((CastExpression)this.receiver).expression.resolvedType, this.actualReceiverType)) {
- scope.problemReporter().unnecessaryCast((CastExpression)this.receiver);
+ TypeBinding resolvedType2 = ((CastExpression)this.receiver).expression.resolvedType;
+ if (TypeBinding.equalsEquals(resolvedType2, this.actualReceiverType)) {
+ if (!scope.environment().usesNullTypeAnnotations() || !NullAnnotationMatching.analyse(this.actualReceiverType, resolvedType2, -1).isAnyMismatch()) {
+ scope.problemReporter().unnecessaryCast((CastExpression)this.receiver);
+ }
}
}
// resolve type arguments (for generic constructor call)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedTypeReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedTypeReference.java
index 537bcbe..b10f83e 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedTypeReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedTypeReference.java
@@ -75,8 +75,15 @@
for (int j = 0; j < i; j++) {
Annotation[] qualifierAnnot = this.annotations[j];
if (qualifierAnnot != null && qualifierAnnot.length > 0) {
- scope.problemReporter().misplacedTypeAnnotations(qualifierAnnot[0], qualifierAnnot[qualifierAnnot.length - 1]);
- this.annotations[j] = null;
+ if (j == 0) {
+ for (int k = 0; k < qualifierAnnot.length; k++) {
+ scope.problemReporter().typeAnnotationAtQualifiedName(qualifierAnnot[k]);
+ }
+ } else {
+ scope.problemReporter().misplacedTypeAnnotations(qualifierAnnot[0],
+ qualifierAnnot[qualifierAnnot.length - 1]);
+ this.annotations[j] = 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 004ddaf..3a2af2c 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
@@ -239,7 +239,7 @@
}
// Process the lambda, taking care not to double report diagnostics. Don't expect any from resolve, Any from code generation should surface, but not those from flow analysis.
- implicitLambda.resolve(currentScope);
+ implicitLambda.resolveType(currentScope, true);
IErrorHandlingPolicy oldPolicy = currentScope.problemReporter().switchErrorHandlingPolicy(silentErrorHandlingPolicy);
try {
implicitLambda.analyseCode(currentScope,
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/ExternalAnnotationProvider.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/ExternalAnnotationProvider.java
index cf7b55c..fd6da1b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/ExternalAnnotationProvider.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/classfmt/ExternalAnnotationProvider.java
@@ -586,7 +586,8 @@
if (an == NULLABLE || an == NONNULL)
start++;
}
- int end = wrapperWithStart(start).computeEnd();
+ SignatureWrapper wrapper1 = wrapperWithStart(start);
+ int end = wrapper1.skipAngleContents(wrapper1.computeEnd());
return end;
}
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 30dbbfc..6e1f66d 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
@@ -2730,7 +2730,7 @@
invoke(Opcodes.OPC_invokevirtual, 1, 1,
ConstantPool.JavaLangInvokeSerializedLambdaConstantPoolName,
ConstantPool.GetCapturedArg, ConstantPool.GetCapturedArgSignature);
- checkcast(isLambda ? mb.declaringClass : ((ReferenceExpression)funcEx).receiverType);
+ checkcast(mb.declaringClass);
sig.append(mb.declaringClass.signature());
}
for (int p = 0, max = outerLocalVariables == null ? 0 : outerLocalVariables.length; p < max; p++) {
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/ConditionalFlowInfo.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/ConditionalFlowInfo.java
index 288fb8f..2d5fd51 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/ConditionalFlowInfo.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/ConditionalFlowInfo.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2012 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
@@ -214,7 +214,9 @@
public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits) {
return unconditionalInits().mergedWith(otherInits);
}
-
+public UnconditionalFlowInfo mergeDefiniteInitsWith(UnconditionalFlowInfo otherInits) {
+ return unconditionalInits().mergeDefiniteInitsWith(otherInits);
+}
public UnconditionalFlowInfo nullInfoLessUnconditionalCopy() {
return unconditionalInitsWithoutSideEffect().
nullInfoLessUnconditionalCopy();
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowInfo.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowInfo.java
index ad63440..67194d5 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowInfo.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowInfo.java
@@ -538,7 +538,8 @@
unconditionalInits();
// if a variable is only initialized in one branch and not initialized in the other,
// then we need to cast a doubt on its initialization in the merged info
- mergedInfo.definiteInits &= initsWhenFalse.unconditionalCopy().definiteInits;
+ mergedInfo.mergeDefiniteInitsWith(initsWhenFalse.unconditionalCopy());
+
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=415997, classify unreachability precisely, IsElseStatementUnreachable could be due to null analysis
if ((mergedInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0 && (initsWhenFalse.tagBits & FlowInfo.UNREACHABLE) == FlowInfo.UNREACHABLE_BY_NULLANALYSIS) {
mergedInfo.tagBits &= ~UNREACHABLE_OR_DEAD;
@@ -558,7 +559,7 @@
unconditionalInits();
// if a variable is only initialized in one branch and not initialized in the other,
// then we need to cast a doubt on its initialization in the merged info
- mergedInfo.definiteInits &= initsWhenTrue.unconditionalCopy().definiteInits;
+ mergedInfo.mergeDefiniteInitsWith(initsWhenTrue.unconditionalCopy());
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=415997, classify unreachability precisely, IsThenStatementUnreachable could be due to null analysis
if ((mergedInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0 && (initsWhenTrue.tagBits & FlowInfo.UNREACHABLE) == FlowInfo.UNREACHABLE_BY_NULLANALYSIS) {
mergedInfo.tagBits &= ~UNREACHABLE_OR_DEAD;
@@ -615,6 +616,8 @@
abstract public UnconditionalFlowInfo mergedWith(
UnconditionalFlowInfo otherInits);
+abstract public UnconditionalFlowInfo mergeDefiniteInitsWith(UnconditionalFlowInfo otherInits);
+
/**
* Return a copy of this unconditional flow info, deprived from its null
* info. {@link #DEAD_END DEAD_END} is returned unmodified.
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/UnconditionalFlowInfo.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/UnconditionalFlowInfo.java
index 584b45d..916a590 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/UnconditionalFlowInfo.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/UnconditionalFlowInfo.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2014 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
@@ -2183,7 +2183,54 @@
public UnconditionalFlowInfo unconditionalInitsWithoutSideEffect() {
return this;
}
+public UnconditionalFlowInfo mergeDefiniteInitsWith(UnconditionalFlowInfo otherInits) {
+ if ((otherInits.tagBits & UNREACHABLE_OR_DEAD) != 0 && this != DEAD_END) {
+ return this;
+ }
+ if ((this.tagBits & UNREACHABLE_OR_DEAD) != 0) {
+ return (UnconditionalFlowInfo) otherInits.copy(); // make sure otherInits won't be affected
+ }
+ // intersection of definitely assigned variables,
+ this.definiteInits &= otherInits.definiteInits;
+ if (this.extra != null) {
+ if (otherInits.extra != null) {
+ // both sides have extra storage
+ int i = 0, length, otherLength;
+ if ((length = this.extra[0].length) < (otherLength = otherInits.extra[0].length)) {
+ // current storage is shorter -> grow current
+ for (int j = 0; j < extraLength; j++) {
+ System.arraycopy(this.extra[j], 0,
+ (this.extra[j] = new long[otherLength]), 0, length);
+ }
+ for (; i < length; i++) {
+ this.extra[0][i] &= otherInits.extra[0][i];
+ }
+ for (; i < otherLength; i++) {
+ this.extra[0][i] = otherInits.extra[0][i];
+ }
+ }
+ else {
+ // current storage is longer
+ for (; i < otherLength; i++) {
+ this.extra[0][i] &= otherInits.extra[0][i];
+ }
+ }
+ } else {
+ for (int i = 0; i < this.extra[0].length; i++) {
+ this.extra[0][i] = 0;
+ }
+ }
+ }
+ else if (otherInits.extra != null) {
+ // no storage here, but other has extra storage.
+ int otherLength = otherInits.extra[0].length;
+ createExtraSpace(otherLength);
+ System.arraycopy(otherInits.extra[0], 0, this.extra[0], 0,
+ otherLength);
+ }
+ return this;
+}
public void resetAssignmentInfo(LocalVariableBinding local) {
resetAssignmentInfo(local.id + this.maxFieldCount);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
index 967230b..3a25dea 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java
@@ -614,7 +614,7 @@
case UnqualifiedFieldAccess :
return OPTION_ReportUnqualifiedFieldAccess;
case UnusedDeclaredThrownException :
- return OPTION_ReportUnusedDeclaredThrownExceptionWhenOverriding;
+ return OPTION_ReportUnusedDeclaredThrownException;
case FinallyBlockNotCompleting :
return OPTION_ReportFinallyBlockNotCompletingNormally;
case InvalidJavadoc :
@@ -1277,6 +1277,27 @@
return this.warningThreshold.isAnySet(irritants) || this.errorThreshold.isAnySet(irritants)
|| this.infoThreshold.isAnySet(irritants);
}
+ /*
+ * Just return the first irritant id that is set to 'ignored'.
+ */
+ public int getIgnoredIrritant(IrritantSet irritants) {
+ int[] bits = irritants.getBits();
+ for (int i = 0; i < IrritantSet.GROUP_MAX; i++) {
+ int bit = bits[i];
+ for (int b = 0; b < IrritantSet.GROUP_SHIFT; b++) {
+ int single = bit & (1 << b);
+ if (single > 0) {
+ single |= (i << IrritantSet.GROUP_SHIFT);
+ if (single == MissingNonNullByDefaultAnnotation)
+ continue;
+ if (!(this.warningThreshold.isSet(single) || this.errorThreshold.isSet(single) || this.infoThreshold.isSet(single))) {
+ return single;
+ }
+ }
+ }
+ }
+ return 0;
+ }
protected void resetDefaults() {
// problem default severities defined on IrritantSet
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java
index 54f524d..280a502 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java
@@ -259,7 +259,9 @@
int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
return (this.bits[group] & singleGroupIrritants) != 0;
}
-
+ public int[] getBits() {
+ return this.bits;
+ }
public IrritantSet set(int singleGroupIrritants) {
int group = (singleGroupIrritants & GROUP_MASK) >> GROUP_SHIFT;
this.bits[group] |= (singleGroupIrritants & ~GROUP_MASK); // erase the group bits
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java
index 9b7b03c..17312a2 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java
@@ -15,6 +15,8 @@
package org.eclipse.jdt.internal.compiler.lookup;
import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.*;
@@ -60,6 +62,8 @@
boolean connectingHierarchy;
private ArrayList<Invocation> inferredInvocations;
+ /** Cache of interned inference variables. Access only via {@link InferenceVariable#get(TypeBinding, int, InvocationSite, Scope, ReferenceBinding)}. */
+ Map<InferenceVariable.InferenceVarKey, InferenceVariable> uniqueInferenceVariables = new HashMap<>();
public CompilationUnitScope(CompilationUnitDeclaration unit, LookupEnvironment environment) {
super(COMPILATION_UNIT_SCOPE, null);
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 f359f9c..2e127a7 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
@@ -292,7 +292,7 @@
this.environment.getNonNullAnnotationName());
break returnType;
} else {
- scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod, useTypeAnnotations);
+ scope.problemReporter().cannotImplementIncompatibleNullness(scope.referenceContext(), currentMethod, inheritedMethod, useTypeAnnotations);
return;
}
}
@@ -308,7 +308,7 @@
scope.problemReporter().illegalReturnRedefinition(srcMethod, inheritedMethod,
this.environment.getNonNullAnnotationName());
else
- scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod, useTypeAnnotations);
+ scope.problemReporter().cannotImplementIncompatibleNullness(scope.referenceContext(), currentMethod, inheritedMethod, useTypeAnnotations);
return;
}
}
@@ -400,7 +400,7 @@
inheritedMethod.declaringClass,
(inheritedNonNullNess == null) ? null : this.environment.getNullableAnnotationName());
} else {
- scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod, false);
+ scope.problemReporter().cannotImplementIncompatibleNullness(scope.referenceContext(), currentMethod, inheritedMethod, false);
}
continue;
} else if (currentNonNullNess == null)
@@ -413,7 +413,7 @@
inheritedMethod.declaringClass,
annotationName);
} else {
- scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod, false);
+ scope.problemReporter().cannotImplementIncompatibleNullness(scope.referenceContext(), currentMethod, inheritedMethod, false);
}
continue;
} else if (inheritedNonNullNess == Boolean.TRUE) {
@@ -438,7 +438,7 @@
if (currentArgument != null)
scope.problemReporter().illegalParameterRedefinition(currentArgument, inheritedMethod.declaringClass, inheritedParameter);
else
- scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod, false);
+ scope.problemReporter().cannotImplementIncompatibleNullness(scope.referenceContext(), currentMethod, inheritedMethod, false);
}
}
}
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 07851ae..f30d941 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
@@ -130,7 +130,6 @@
/** The inference variables for which as solution is sought. */
InferenceVariable[] inferenceVariables;
- int nextVarId;
/** Constraints that have not yet been reduced and incorporated. */
ConstraintFormula[] initialConstraints;
@@ -164,43 +163,12 @@
/** Not per JLS: signal when current is ready to directly merge all bounds from inner. */
private boolean directlyAcceptingInnerBounds = false;
- // InferenceVariable interning:
- private InferenceVariable[] internedVariables;
-
- private InferenceVariable getInferenceVariable(TypeBinding typeParameter, int rank, InvocationSite site) {
- InferenceContext18 outermostContext = this.environment.currentInferenceContext;
- if (outermostContext == null)
- outermostContext = this;
- int i = 0;
- InferenceVariable[] interned = outermostContext.internedVariables;
- if (interned == null) {
- outermostContext.internedVariables = new InferenceVariable[10];
- } else {
- int len = interned.length;
- for (i = 0; i < len; i++) {
- InferenceVariable var = interned[i];
- if (var == null)
- break;
- if (var.typeParameter == typeParameter && var.rank == rank && isSameSite(var.site, site)) //$IDENTITY-COMPARISON$
- return var;
- }
- if (i >= len)
- System.arraycopy(interned, 0, outermostContext.internedVariables = new InferenceVariable[len+10], 0, len);
- }
- boolean differentContext = outermostContext != this;
- int id = differentContext ? Math.max(this.nextVarId, outermostContext.nextVarId) : this.nextVarId;
- this.nextVarId = id + 1;
- if (differentContext)
- outermostContext.nextVarId = this.nextVarId;
- return outermostContext.internedVariables[i] = new InferenceVariable(typeParameter, rank, id, site, this.environment, this.object);
- }
-
- boolean isSameSite(InvocationSite site1, InvocationSite site2) {
+ public static boolean isSameSite(InvocationSite site1, InvocationSite site2) {
if (site1 == site2)
return true;
if (site1 == null || site2 == null)
return false;
- if (site1.sourceStart() == site2.sourceStart() && site1.sourceEnd() == site2.sourceEnd() && site1.toString().equals(site2.toString()))
+ if (site1.sourceStart() == site2.sourceStart() && site1.sourceEnd() == site2.sourceEnd())
return true;
return false;
}
@@ -336,7 +304,7 @@
}
InferenceVariable[] newVariables = new InferenceVariable[len];
for (int i = 0; i < len; i++)
- newVariables[i] = getInferenceVariable(typeVariables[i], i, this.currentInvocation);
+ newVariables[i] = InferenceVariable.get(typeVariables[i], i, this.currentInvocation, this.scope, this.object);
addInferenceVariables(newVariables);
return newVariables;
}
@@ -364,7 +332,7 @@
newVariables[i] = (InferenceVariable) typeVariables[i]; // prevent double substitution of an already-substituted inferenceVariable
else
toAdd[numToAdd++] =
- newVariables[i] = getInferenceVariable(typeVariables[i], i, this.currentInvocation);
+ newVariables[i] = InferenceVariable.get(typeVariables[i], i, this.currentInvocation, this.scope, this.object);
}
if (numToAdd > 0) {
int start = 0;
@@ -1565,18 +1533,6 @@
if (!isSameSite(innerCtx.currentInvocation, this.currentInvocation))
innerCtx.outerContext = this;
this.usesUncheckedConversion = innerCtx.usesUncheckedConversion;
- for (InferenceVariable variable : this.inferenceVariables)
- if (!isInterned(variable))
- variable.updateSourceName(this.nextVarId++);
- }
-
- boolean isInterned(InferenceVariable iv) {
- if (this.internedVariables != null)
- for (int i = 0; i < this.internedVariables.length; i++) {
- if (this.internedVariables[i] == iv) //$IDENTITY-COMPARISON$
- return true;
- }
- return false;
}
public void resumeSuspendedInference(SuspendedInferenceRecord record) {
@@ -1589,8 +1545,6 @@
// move to back, add previous to front:
System.arraycopy(this.inferenceVariables, 0, this.inferenceVariables=new InferenceVariable[l1+l2], l2, l1);
System.arraycopy(record.inferenceVariables, 0, this.inferenceVariables, 0, l2);
- for (int i=l1;i<l1+l2;i++)
- this.inferenceVariables[i].updateSourceName(this.nextVarId++);
}
// replace invocation site & arguments:
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceSubstitution.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceSubstitution.java
index 180f770..d482c7a 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceSubstitution.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceSubstitution.java
@@ -36,7 +36,7 @@
public TypeBinding substitute(Substitution substitution, TypeBinding originalType) {
for (int i = 0; i < this.variables.length; i++) {
InferenceVariable variable = this.variables[i];
- if (this.site == variable.site && TypeBinding.equalsEquals(getP(i), originalType)) {
+ if (InferenceContext18.isSameSite(this.site, variable.site) && TypeBinding.equalsEquals(getP(i), originalType)) {
if (this.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled && originalType.hasNullTypeAnnotations())
return this.environment.createAnnotatedType(variable.withoutToplevelNullAnnotation(), originalType.getTypeAnnotations());
return variable;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java
index b999b85..6b78a5f 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceVariable.java
@@ -10,6 +10,7 @@
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;
+import java.util.Map;
import java.util.Set;
import org.eclipse.jdt.core.compiler.CharOperation;
@@ -18,14 +19,74 @@
* Implementation of 18.1.1 in JLS8
*/
public class InferenceVariable extends TypeVariableBinding {
+
+ /** Structured key for interning. */
+ static class InferenceVarKey {
+ /*@NonNull*/ TypeBinding typeParameter;
+ long position;
+ int rank;
+ InferenceVarKey(TypeBinding typeParameter, InvocationSite site, int rank) {
+ this.typeParameter = typeParameter;
+ this.position = ((long) site.sourceStart() << 32) + site.sourceEnd();
+ this.rank = rank;
+ }
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + (int) (this.position ^ (this.position >>> 32));
+ result = prime * result + this.rank;
+ result = prime * result + this.typeParameter.id;
+ return result;
+ }
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (!(obj instanceof InferenceVarKey))
+ return false;
+ InferenceVarKey other = (InferenceVarKey) obj;
+ if (this.position != other.position)
+ return false;
+ if (this.rank != other.rank)
+ return false;
+ if (TypeBinding.notEquals(this.typeParameter, other.typeParameter))
+ return false;
+ return true;
+ }
+ }
+
+ /**
+ * Create or retrieve the inference variable representing the given typeParameter.
+ * Inference variables are interned to avoid duplication due to lambda copying.
+ */
+ public static InferenceVariable get(TypeBinding typeParameter, int rank, InvocationSite site, Scope scope, ReferenceBinding object) {
+ Map<InferenceVarKey, InferenceVariable> uniqueInferenceVariables = scope.compilationUnitScope().uniqueInferenceVariables;
+ InferenceVariable var = null;
+ InferenceVarKey key = null;
+ if (site != null && typeParameter != null) {
+ key = new InferenceVarKey(typeParameter, site, rank);
+ var = uniqueInferenceVariables.get(key);
+ }
+ if (var == null) {
+ int newVarId = uniqueInferenceVariables.size();
+ var = new InferenceVariable(typeParameter, rank, newVarId, site, scope.environment(), object);
+ if (key != null)
+ uniqueInferenceVariables.put(key, var);
+ }
+ return var;
+ }
+
InvocationSite site;
TypeBinding typeParameter;
long nullHints; // one of TagBits.{AnnotationNonNull,AnnotationNullable} may steer inference into inferring nullness as well; set both bits to request avoidance.
private InferenceVariable prototype;
- int varId; // this is used for constructing a source name like T#0. NB: varId and sourceName are mutable, to be updated when two InferenceContext18 are integrated.
+ int varId; // this is used for constructing a source name like T#0.
- public InferenceVariable(TypeBinding typeParameter, int parameterRank, int iVarId, InvocationSite site, LookupEnvironment environment, ReferenceBinding object) {
+ private InferenceVariable(TypeBinding typeParameter, int parameterRank, int iVarId, InvocationSite site, LookupEnvironment environment, ReferenceBinding object) {
this(typeParameter, parameterRank, site,
CharOperation.concat(typeParameter.shortReadableName(), Integer.toString(iVarId).toCharArray(), '#'),
environment, object);
@@ -49,15 +110,7 @@
this.superclass = object;
this.prototype = this;
}
- void updateSourceName(int newId) {
- int hashPos = CharOperation.indexOf('#', this.sourceName);
- this.varId = newId;
- this.sourceName = CharOperation.concat(
- CharOperation.subarray(this.sourceName, 0, hashPos),
- Integer.toString(this.varId).toCharArray(),
- '#');
- }
-
+
@Override
public TypeBinding clone(TypeBinding enclosingType) {
InferenceVariable clone = new InferenceVariable(this.typeParameter, this.rank, this.site, this.sourceName, this.environment, this.superclass);
@@ -131,17 +184,18 @@
public int hashCode() {
int code = this.typeParameter.hashCode() + 17 * this.rank;
- if (this.site != null)
- return 31 * code + this.site.hashCode();
- else
- return code;
+ if (this.site != null) {
+ code = 31 * code + this.site.sourceStart();
+ code = 31 * code + this.site.sourceEnd();
+ }
+ return code;
}
public boolean equals(Object obj) {
if (!(obj instanceof InferenceVariable))
return false;
InferenceVariable other = (InferenceVariable) obj;
return this.rank == other.rank
- && this.site == other.site
+ && InferenceContext18.isSameSite(this.site, other.site)
&& TypeBinding.equalsEquals(this.typeParameter, other.typeParameter);
}
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 67faad1..55cc090 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
@@ -569,12 +569,16 @@
//pre: null annotation analysis is enabled
protected void fillInDefaultNonNullness18(AbstractMethodDeclaration sourceMethod, LookupEnvironment env) {
+ MethodBinding original = original();
+ if(original == null) {
+ return;
+ }
if (hasNonNullDefaultFor(DefaultLocationParameter, true)) {
boolean added = false;
int length = this.parameters.length;
for (int i = 0; i < length; i++) {
TypeBinding parameter = this.parameters[i];
- if (!parameter.acceptsNonNullDefault())
+ if (!original.parameters[i].acceptsNonNullDefault())
continue;
long existing = parameter.tagBits & TagBits.AnnotationNullMASK;
if (existing == 0L) {
@@ -592,7 +596,7 @@
if (added)
this.tagBits |= TagBits.HasParameterAnnotations;
}
- if (this.returnType != null && hasNonNullDefaultFor(DefaultLocationReturnType, true) && this.returnType.acceptsNonNullDefault()) {
+ if (original.returnType != null && hasNonNullDefaultFor(DefaultLocationReturnType, true) && original.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
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
index aea2423..bbd02d3 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
@@ -60,6 +60,12 @@
*/
public static MethodBinding computeCompatibleMethod(MethodBinding originalMethod, TypeBinding[] arguments, Scope scope, InvocationSite invocationSite)
{
+ LookupEnvironment environment = scope.environment();
+ if ((originalMethod.tagBits & TagBits.IsNullnessKnown) == 0) {
+ // ensure nullness of originalMethod is known (but we are not interested in reporting problems against originalMethod)
+ new ImplicitNullAnnotationVerifier(environment, environment.globalOptions.inheritNullAnnotations)
+ .checkImplicitNullAnnotations(originalMethod, null/*srcMethod*/, false, scope);
+ }
ParameterizedGenericMethodBinding methodSubstitute;
TypeVariableBinding[] typeVariables = originalMethod.typeVariables;
TypeBinding[] substitutes = invocationSite.genericTypeArguments();
@@ -72,7 +78,7 @@
// incompatible due to wrong arity
return new ProblemMethodBinding(originalMethod, originalMethod.selector, substitutes, ProblemReasons.TypeParameterArityMismatch);
}
- methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, substitutes);
+ methodSubstitute = environment.createParameterizedGenericMethod(originalMethod, substitutes);
break computeSubstitutes;
}
// perform type argument inference (15.12.2.7)
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
index 40cae44..20639ff 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java
@@ -1149,7 +1149,7 @@
else // WildcardBinding, CaptureBinding have no sourceName
nameBuffer.append(this.type.readableName());
}
- if (this.arguments != null && this.arguments.length > 0) { // empty arguments array happens when PTB has been created just to capture type annotations
+ if (this.arguments != null && this.arguments.length > 0 && !isRawType()) { // empty arguments array happens when PTB has been created just to capture type annotations
nameBuffer.append('<');
for (int i = 0, length = this.arguments.length; i < length; i++) {
if (i > 0) nameBuffer.append(',');
@@ -1177,7 +1177,7 @@
else // WildcardBinding, CaptureBinding have no sourceName
nameBuffer.append(this.type.shortReadableName());
}
- if (this.arguments != null && this.arguments.length > 0) { // empty arguments array happens when PTB has been created just to capture type annotations
+ if (this.arguments != null && this.arguments.length > 0 && !isRawType()) { // empty arguments array happens when PTB has been created just to capture type annotations
nameBuffer.append('<');
for (int i = 0, length = this.arguments.length; i < length; i++) {
if (i > 0) nameBuffer.append(',');
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeSystem.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeSystem.java
index 8c7c2c7..965f055 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeSystem.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeSystem.java
@@ -18,7 +18,6 @@
import java.util.HashMap;
-import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
import org.eclipse.jdt.internal.compiler.util.Util;
@@ -168,19 +167,7 @@
urb = (UnresolvedReferenceBinding) type;
ReferenceBinding resolvedType = urb.resolvedType;
if (resolvedType != null) {
- if(CharOperation.indexOf('$', type.sourceName()) > 0) {
- type = this.environment.convertToRawType(resolvedType, false);
- } else {
- type = resolvedType;
- }
- } else if (CharOperation.indexOf('$', type.sourceName()) > 0) {
- boolean mayTolerateMissingType = this.environment.mayTolerateMissingType;
- this.environment.mayTolerateMissingType = true;
- try {
- type = BinaryTypeBinding.resolveType(type, this.environment, true); // to ensure unique id assignment (when enclosing type is parameterized, inner type is also)
- } finally {
- this.environment.mayTolerateMissingType = mayTolerateMissingType;
- }
+ type = resolvedType;
}
}
try {
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 0fe0324..9386b62 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
@@ -984,7 +984,6 @@
TypeBinding [] annotatedTypes = getDerivedTypesForDeferredInitialization();
for (int i = 0, length = annotatedTypes == null ? 0 : annotatedTypes.length; i < length; i++) {
TypeVariableBinding annotatedType = (TypeVariableBinding) annotatedTypes[i];
- if (annotatedType.firstBound == null)
annotatedType.firstBound = firstBound;
}
}
@@ -1001,7 +1000,6 @@
TypeBinding [] annotatedTypes = getDerivedTypesForDeferredInitialization();
for (int i = 0, length = annotatedTypes == null ? 0 : annotatedTypes.length; i < length; i++) {
TypeVariableBinding annotatedType = (TypeVariableBinding) annotatedTypes[i];
- if (annotatedType.superclass == null)
annotatedType.superclass = superclass;
}
}
@@ -1016,7 +1014,6 @@
TypeBinding [] annotatedTypes = getDerivedTypesForDeferredInitialization();
for (int i = 0, length = annotatedTypes == null ? 0 : annotatedTypes.length; i < length; i++) {
TypeVariableBinding annotatedType = (TypeVariableBinding) annotatedTypes[i];
- if (annotatedType.superInterfaces == null)
annotatedType.superInterfaces = superInterfaces;
}
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java
index 5fecec4..2a1fd28 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/AbstractCommentParser.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2000, 2013 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
@@ -172,7 +172,13 @@
}
this.lineEnd = (this.linePtr == this.lastLinePtr) ? this.javadocEnd: this.scanner.getLineEnd(this.linePtr) - 1;
this.javadocTextEnd = this.javadocEnd - 2; // supposed text end, it will be refined later...
-
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345
+ // when parsing tags such as @code and @literal,
+ // any tag should be discarded and considered as plain text until
+ // properly closed with closing brace
+ boolean considerTagAsPlainText = false;
+ // internal counter for opening braces
+ int openingBraces = 0;
// Loop on each comment character
int textEndPosition = -1;
while (!this.abort && this.index < this.javadocEnd) {
@@ -208,7 +214,20 @@
switch (nextCharacter) {
case '@' :
// Start tag parsing only if we are on line beginning or at inline tag beginning
- if ((!this.lineStarted || previousChar == '{')) {
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345: ignore all tags when inside @literal or @code tags
+ if (considerTagAsPlainText) {
+ // new tag found
+ if (!this.lineStarted) {
+ // we may want to report invalid syntax when no closing brace found,
+ // or when incoherent number of closing braces found
+ if (openingBraces > 0 && this.reportProblems) {
+ this.sourceParser.problemReporter().javadocUnterminatedInlineTag(this.inlineTagStart, invalidInlineTagLineEnd);
+ }
+ considerTagAsPlainText = false;
+ this.inlineTagStarted = false;
+ openingBraces = 0;
+ }
+ } else if ((!this.lineStarted || previousChar == '{')) {
if (this.inlineTagStarted) {
setInlineTagStarted(false);
// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=53279
@@ -252,6 +271,12 @@
invalidTagLineEnd = this.lineEnd;
textEndPosition = this.index;
}
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345
+ // dealing with @literal or @code tags: ignore next tags
+ if (!isFormatterParser && (this.tagValue == TAG_LITERAL_VALUE || this.tagValue == TAG_CODE_VALUE)) {
+ considerTagAsPlainText = true;
+ openingBraces++;
+ }
} catch (InvalidInputException e) {
consumeToken();
}
@@ -284,13 +309,24 @@
if (verifText && this.tagValue == TAG_RETURN_VALUE && this.returnStatement != null) {
refreshReturnStatement();
}
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345: when ignoring tags, only decrement the opening braces counter
+ if (considerTagAsPlainText) {
+ invalidInlineTagLineEnd = this.lineEnd;
+ if (--openingBraces == 0) {
+ considerTagAsPlainText = false; // re-enable tag validation
+ }
+ }
if (this.inlineTagStarted) {
textEndPosition = this.index - 1;
- if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {
- pushText(this.textStart, textEndPosition);
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345: do not push text yet if ignoring tags
+ if (!considerTagAsPlainText) {
+ if (this.lineStarted && this.textStart != -1 && this.textStart < textEndPosition) {
+ pushText(this.textStart, textEndPosition);
+ }
+ refreshInlineTagPosition(previousPosition);
}
- refreshInlineTagPosition(previousPosition);
- if (!isFormatterParser) this.textStart = this.index;
+ if (!isFormatterParser && !considerTagAsPlainText)
+ this.textStart = this.index;
setInlineTagStarted(false);
} else {
if (!this.lineStarted) {
@@ -304,7 +340,10 @@
if (verifText && this.tagValue == TAG_RETURN_VALUE && this.returnStatement != null) {
refreshReturnStatement();
}
- if (this.inlineTagStarted) {
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345: count opening braces when ignoring tags
+ if (considerTagAsPlainText) {
+ openingBraces++;
+ } else if (this.inlineTagStarted) {
setInlineTagStarted(false);
// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=53279
// Cannot have opening brace in inline comment
@@ -325,7 +364,8 @@
this.textStart = previousPosition;
}
this.lineStarted = true;
- this.inlineTagStart = previousPosition;
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345: do not update tag start position when ignoring tags
+ if (!considerTagAsPlainText) this.inlineTagStart = previousPosition;
break;
case '*' :
// Store the star position as text start while formatting
@@ -395,7 +435,8 @@
// bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=53279
// Cannot leave comment inside inline comment
- if (this.inlineTagStarted) {
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=206345: handle unterminated @code or @literal tag
+ if (this.inlineTagStarted || considerTagAsPlainText) {
if (this.reportProblems) {
int end = this.javadocTextEnd<invalidInlineTagLineEnd ? this.javadocTextEnd : invalidInlineTagLineEnd;
if (this.index >= this.javadocEnd) end = invalidInlineTagLineEnd;
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
index 12822b2..28f8c44 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java
@@ -1594,6 +1594,8 @@
return ProblemSeverities.Warning;
case IProblem.IllegalUseOfUnderscoreAsAnIdentifier:
return this.underScoreIsLambdaParameter ? ProblemSeverities.Error : ProblemSeverities.Warning;
+ case IProblem.ProblemNotAnalysed:
+ return ProblemSeverities.Info; // Not configurable
}
int irritant = getIrritant(problemID);
if (irritant != 0) {
@@ -5861,6 +5863,19 @@
severity,
annotation.sourceStart, annotation.sourceEnd);
}
+public void nullAnnotationAtQualifyingType(Annotation annotation) {
+ String[] arguments = new String[] {
+ String.valueOf(annotation.resolvedType.readableName())
+ };
+ String[] shortArguments = new String[] {
+ String.valueOf(annotation.resolvedType.shortReadableName())
+ };
+ int severity = ProblemSeverities.Error | ProblemSeverities.Fatal;
+ handle(IProblem.NullAnnotationAtQualifyingType,
+ arguments, shortArguments,
+ severity,
+ annotation.sourceStart, annotation.sourceEnd);
+}
public void nullAnnotationUnsupportedLocation(TypeReference type) {
int sourceEnd = type.sourceEnd;
if (type instanceof ParameterizedSingleTypeReference) {
@@ -8952,6 +8967,14 @@
token.sourceStart,
token.sourceEnd);
}
+public void problemNotAnalysed(Expression token, String optionKey) {
+ this.handle(
+ IProblem.ProblemNotAnalysed,
+ optionKey != null ? new String[]{optionKey} : new String[]{},
+ new String[] { token.constant.stringValue() },
+ token.sourceStart,
+ token.sourceEnd);
+}
public void useAssertAsAnIdentifier(int sourceStart, int sourceEnd) {
this.handle(
IProblem.UseAssertAsAnIdentifier,
@@ -9643,11 +9666,11 @@
location.sourceEnd);
}
-public void cannotImplementIncompatibleNullness(MethodBinding currentMethod, MethodBinding inheritedMethod, boolean showReturn) {
+public void cannotImplementIncompatibleNullness(ReferenceContext context, MethodBinding currentMethod, MethodBinding inheritedMethod, boolean showReturn) {
int sourceStart = 0, sourceEnd = 0;
- if (this.referenceContext instanceof TypeDeclaration) {
- sourceStart = ((TypeDeclaration) this.referenceContext).sourceStart;
- sourceEnd = ((TypeDeclaration) this.referenceContext).sourceEnd;
+ if (context instanceof TypeDeclaration) {
+ sourceStart = ((TypeDeclaration) context).sourceStart;
+ sourceEnd = ((TypeDeclaration) context).sourceEnd;
}
String[] problemArguments = {
showReturn
@@ -10416,6 +10439,10 @@
annotation.sourceStart,
annotation.sourceEnd);
}
+public void typeAnnotationAtQualifiedName(Annotation annotation) {
+ this.handle(IProblem.TypeAnnotationAtQualifiedName, NoArgument, NoArgument, annotation.sourceStart,
+ annotation.sourceEnd);
+ }
public void genericInferenceError(String message, InvocationSite invocationSite) {
genericInferenceProblem(message, invocationSite, ProblemSeverities.Error);
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties
index 4746474..d07d1ee 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties
@@ -862,9 +862,12 @@
1057 = strictfp is not permitted for abstract interface method {0}
1058 = Default methods are allowed only in interfaces.
1059 = Cannot infer type argument(s) for <{0}> {1}
+1060 = Illegally placed annotation: type annotations must directly precede the simple name of the type they are meant to affect (or the [] for arrays)
+1061 = The nullness annotation ''{0}'' is not applicable at this location, it must be placed directly before the nested type name.
1100 = Problem detected during type inference: {0}
-
+#1101 is already used up but deprecated
+1102 = At least one of the problems in category ''{0}'' is not analysed due to a compiler option being ignored
### ELABORATIONS
## Access restrictions
78592 = The type ''{1}'' is not API (restriction on classpath entry ''{0}'')
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java
index e033637..818bb0b 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/util/Util.java
@@ -1198,7 +1198,7 @@
count++;
}
} catch (ArrayIndexOutOfBoundsException e) {
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java
index 7757fed..aae7faa 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AST.java
@@ -503,7 +503,7 @@
return (CompilationUnit) result;
} catch (IllegalStateException e) {
// convert ASTParser's complaints into old form
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
}
@@ -577,7 +577,7 @@
return (CompilationUnit) result;
} catch (IllegalStateException e) {
// convert ASTParser's complaints into old form
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
}
@@ -815,21 +815,19 @@
} catch (NoSuchMethodException e) {
// all AST node classes have a Foo(AST) constructor
// therefore nodeClass is not legit
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
} catch (InstantiationException e) {
// all concrete AST node classes can be instantiated
// therefore nodeClass is not legit
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
} catch (IllegalAccessException e) {
// all AST node classes have an accessible Foo(AST) constructor
// therefore nodeClass is not legit
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
} catch (InvocationTargetException e) {
// concrete AST node classes do not die in the constructor
// therefore nodeClass is not legit
- IllegalArgumentException iae = new IllegalArgumentException();
- iae.initCause(e.getCause());
- throw iae;
+ throw new IllegalArgumentException(e.getCause());
}
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTParser.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTParser.java
index fa4e478..4452ea6 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTParser.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTParser.java
@@ -299,7 +299,7 @@
throw new IllegalStateException("invalid environment settings"); //$NON-NLS-1$
}
} catch (IllegalArgumentException e) {
- throw new IllegalStateException("invalid environment settings"); //$NON-NLS-1$
+ throw new IllegalStateException("invalid environment settings", e); //$NON-NLS-1$
}
return allClasspaths;
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CharacterLiteral.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CharacterLiteral.java
index b4b1da6..512a8d0 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CharacterLiteral.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CharacterLiteral.java
@@ -286,7 +286,7 @@
throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
}
} catch (InvalidInputException e) {
- throw new IllegalArgumentException("illegal character literal");//$NON-NLS-1$
+ throw new IllegalArgumentException("illegal character literal", e);//$NON-NLS-1$
}
}
nextChar = scanner.getNextChar();
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnitResolver.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnitResolver.java
index 15ca187..bbb9ab2 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnitResolver.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/CompilationUnitResolver.java
@@ -769,7 +769,7 @@
throw new IllegalArgumentException(element + " has an unexpected type"); //$NON-NLS-1$
binaryElementPositions.put(key, i);
} catch (JavaModelException e) {
- throw new IllegalArgumentException(element + " does not exist"); //$NON-NLS-1$
+ throw new IllegalArgumentException(element + " does not exist", e); //$NON-NLS-1$
}
}
}
@@ -792,7 +792,7 @@
try {
finder.search();
} catch (JavaModelException e) {
- throw new IllegalArgumentException(element + " does not exist"); //$NON-NLS-1$
+ throw new IllegalArgumentException(element + " does not exist", e); //$NON-NLS-1$
}
this.bindings[index] = finder.foundBinding;
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java
index 1136b34..6bb5390 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/DocCommentParser.java
@@ -1,5 +1,5 @@
/*******************************************************************************
- * Copyright (c) 2004, 2013 IBM Corporation and others.
+ * Copyright (c) 2004, 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
@@ -427,6 +427,9 @@
if (length == TAG_CATEGORY_LENGTH && CharOperation.equals(TAG_CATEGORY, tagName)) {
this.tagValue = TAG_CATEGORY_VALUE;
valid = parseIdentifierTag(false); // TODO (frederic) reconsider parameter value when @category will be significant in spec
+ } else if (length == TAG_CODE_LENGTH && CharOperation.equals(TAG_CODE, tagName)) {
+ this.tagValue = TAG_CODE_VALUE;
+ createTag();
} else {
this.tagValue = TAG_OTHERS_VALUE;
createTag();
@@ -490,8 +493,11 @@
this.tagValue = TAG_LINK_VALUE;
} else if (length == TAG_LINKPLAIN_LENGTH && CharOperation.equals(TAG_LINKPLAIN, tagName)) {
this.tagValue = TAG_LINKPLAIN_VALUE;
+ } else if (length == TAG_LITERAL_LENGTH && CharOperation.equals(TAG_LITERAL, tagName)) {
+ this.tagValue = TAG_LITERAL_VALUE;
}
- if (this.tagValue != NO_TAG_VALUE) {
+
+ if (this.tagValue != NO_TAG_VALUE && this.tagValue != TAG_LITERAL_VALUE) {
if (this.inlineTagStarted) {
valid = parseReference();
} else {
@@ -500,7 +506,7 @@
valid = false;
}
} else {
- this.tagValue = TAG_OTHERS_VALUE;
+ if (this.tagValue == NO_TAG_VALUE) this.tagValue = TAG_OTHERS_VALUE;
createTag();
}
break;
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Javadoc.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Javadoc.java
index 85ae7ff..4d4abe5 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Javadoc.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Javadoc.java
@@ -264,7 +264,7 @@
throw new IllegalArgumentException();
}
} catch (InvalidInputException e) {
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
preValueChange(COMMENT_PROPERTY);
this.comment = docComment;
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SimpleName.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SimpleName.java
index 60dab87..fda05fb 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SimpleName.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/SimpleName.java
@@ -199,9 +199,7 @@
throw new IllegalArgumentException("Invalid identifier : >" + identifier + "<"); //$NON-NLS-1$//$NON-NLS-2$
}
} catch (InvalidInputException e) {
- IllegalArgumentException iae = new IllegalArgumentException("Invalid identifier : >" + identifier + "<"); //$NON-NLS-1$//$NON-NLS-2$
- iae.initCause(e);
- throw iae;
+ throw new IllegalArgumentException("Invalid identifier : >" + identifier + "<", e); //$NON-NLS-1$//$NON-NLS-2$
}
} finally {
this.ast.scanner.sourceLevel = sourceLevel;
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Statement.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Statement.java
index dffc912..60ba518 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Statement.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/Statement.java
@@ -155,7 +155,7 @@
throw new IllegalArgumentException();
}
} catch (InvalidInputException e) {
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
}
// we do not consider the obsolete comment as a structureal property
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
index fb0571a..7ecfa08 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
@@ -4346,8 +4346,6 @@
}
final void handleException(Throwable e) {
- IllegalArgumentException runtimeException= new IllegalArgumentException("Document does not match the AST"); //$NON-NLS-1$
- runtimeException.initCause(e);
- throw runtimeException;
+ throw new IllegalArgumentException("Document does not match the AST", e); //$NON-NLS-1$
}
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFormatter.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFormatter.java
index 2bd730c..efb8893 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFormatter.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteFormatter.java
@@ -429,7 +429,7 @@
try {
doc.addPosition(POS_CATEGORY, positions[i]);
} catch (BadLocationException e) {
- throw new IllegalArgumentException("Position outside of string. offset: " + positions[i].offset + ", length: " + positions[i].length + ", string size: " + string.length()); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
+ throw new IllegalArgumentException("Position outside of string. offset: " + positions[i].offset + ", length: " + positions[i].length + ", string size: " + string.length(), e); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
}
}
}
diff --git a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/core/formatter/DefaultCodeFormatterConstants.java b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/core/formatter/DefaultCodeFormatterConstants.java
index adb1566..987a744 100644
--- a/org.eclipse.jdt.core/formatter/org/eclipse/jdt/core/formatter/DefaultCodeFormatterConstants.java
+++ b/org.eclipse.jdt.core/formatter/org/eclipse/jdt/core/formatter/DefaultCodeFormatterConstants.java
@@ -4408,7 +4408,7 @@
int existingValue = Integer.parseInt(value);
return (existingValue & Alignment.M_FORCE) != 0;
} catch (NumberFormatException e) {
- throw new IllegalArgumentException("Alignment value is not an integer: " + value); //$NON-NLS-1$
+ throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$
}
}
@@ -4435,7 +4435,7 @@
return INDENT_DEFAULT;
}
} catch (NumberFormatException e) {
- throw new IllegalArgumentException("Alignment value is not an integer: " + value); //$NON-NLS-1$
+ throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$
}
}
@@ -4478,7 +4478,7 @@
return WRAP_NO_SPLIT;
}
} catch (NumberFormatException e) {
- throw new IllegalArgumentException("Alignment value is not an integer: " + value); //$NON-NLS-1$
+ throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$
}
}
/**
@@ -4504,7 +4504,7 @@
}
return String.valueOf(existingValue);
} catch (NumberFormatException e) {
- throw new IllegalArgumentException("Alignment value is not an integer: " + value); //$NON-NLS-1$
+ throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$
}
}
@@ -4547,7 +4547,7 @@
}
return String.valueOf(existingValue);
} catch (NumberFormatException e) {
- throw new IllegalArgumentException("Alignment value is not an integer: " + value); //$NON-NLS-1$
+ throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$
}
}
/**
@@ -4605,7 +4605,7 @@
}
return String.valueOf(existingValue);
} catch (NumberFormatException e) {
- throw new IllegalArgumentException("Alignment value is not an integer: " + value); //$NON-NLS-1$
+ throw new IllegalArgumentException("Alignment value is not an integer: " + value, e); //$NON-NLS-1$
}
}
}
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
index e186a14..6e5aa19 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/JavaCore.java
@@ -114,19 +114,6 @@
import java.util.Hashtable;
import java.util.Map;
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IConfigurationElement;
-import org.eclipse.core.runtime.IExtension;
-import org.eclipse.core.runtime.IExtensionPoint;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.OperationCanceledException;
-import org.eclipse.core.runtime.Path;
-import org.eclipse.core.runtime.Platform;
-import org.eclipse.core.runtime.Plugin;
-import org.eclipse.core.runtime.QualifiedName;
-import org.eclipse.core.runtime.SubMonitor;
-import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
@@ -140,6 +127,19 @@
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IWorkspaceRunnable;
import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.OperationCanceledException;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Plugin;
+import org.eclipse.core.runtime.QualifiedName;
+import org.eclipse.core.runtime.SubMonitor;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
@@ -150,10 +150,26 @@
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
-import org.eclipse.jdt.internal.core.*;
+import org.eclipse.jdt.internal.core.BatchOperation;
+import org.eclipse.jdt.internal.core.BufferManager;
+import org.eclipse.jdt.internal.core.ClasspathAccessRule;
+import org.eclipse.jdt.internal.core.ClasspathAttribute;
+import org.eclipse.jdt.internal.core.ClasspathEntry;
+import org.eclipse.jdt.internal.core.ClasspathValidation;
+import org.eclipse.jdt.internal.core.CreateTypeHierarchyOperation;
+import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
+import org.eclipse.jdt.internal.core.ExternalFoldersManager;
+import org.eclipse.jdt.internal.core.JavaCorePreferenceInitializer;
+import org.eclipse.jdt.internal.core.JavaModel;
+import org.eclipse.jdt.internal.core.JavaModelManager;
+import org.eclipse.jdt.internal.core.JavaProject;
+import org.eclipse.jdt.internal.core.Region;
+import org.eclipse.jdt.internal.core.SetContainerOperation;
+import org.eclipse.jdt.internal.core.SetVariablesOperation;
import org.eclipse.jdt.internal.core.builder.JavaBuilder;
import org.eclipse.jdt.internal.core.builder.State;
import org.eclipse.jdt.internal.core.nd.indexer.Indexer;
+import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.jdt.internal.core.util.MementoTokenizer;
import org.eclipse.jdt.internal.core.util.Messages;
import org.eclipse.jdt.internal.core.util.Util;
@@ -4116,7 +4132,7 @@
// if factory is null, default factory must be used
if (factory == null) factory = BufferManager.getDefaultBufferManager().getDefaultBufferFactory();
- return getWorkingCopies(BufferFactoryWrapper.create(factory));
+ return getWorkingCopies(org.eclipse.jdt.internal.core.BufferFactoryWrapper.create(factory));
}
/**
@@ -4181,14 +4197,14 @@
JavaModelManager manager = JavaModelManager.getJavaModelManager();
try {
SubMonitor subMonitor = mainMonitor.split(50).setWorkRemaining(100); // 50% of the time is spent in initializing containers and variables
- subMonitor.worked(5); // give feedback to the user that something is happening
+ subMonitor.split(5); // give feedback to the user that something is happening
manager.batchContainerInitializationsProgress.initializeAfterLoadMonitor.set(subMonitor);
if (manager.forceBatchInitializations(true/*initAfterLoad*/)) { // if no other thread has started the batch container initializations
manager.getClasspathContainer(Path.EMPTY, null); // force the batch initialization
} else { // else wait for the batch initialization to finish
while (manager.batchContainerInitializations == JavaModelManager.BATCH_INITIALIZATION_IN_PROGRESS) {
subMonitor.subTask(manager.batchContainerInitializationsProgress.subTaskName);
- subMonitor.worked(manager.batchContainerInitializationsProgress.getWorked());
+ subMonitor.split(manager.batchContainerInitializationsProgress.getWorked());
synchronized(manager) {
try {
manager.wait(100);
@@ -4264,38 +4280,8 @@
// dummy query for waiting until the indexes are ready
mainMonitor.subTask(Messages.javamodel_configuring_searchengine);
- SearchEngine engine = new SearchEngine();
- IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
- try {
- engine.searchAllTypeNames(
- null,
- SearchPattern.R_EXACT_MATCH,
- "!@$#!@".toCharArray(), //$NON-NLS-1$
- SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE,
- IJavaSearchConstants.CLASS,
- scope,
- new TypeNameRequestor() {
- public void acceptType(
- int modifiers,
- char[] packageName,
- char[] simpleTypeName,
- char[][] enclosingTypeNames,
- String path) {
- // no type to accept
- }
- },
- // will not activate index query caches if indexes are not ready, since it would take to long
- // to wait until indexes are fully rebuild
- IJavaSearchConstants.CANCEL_IF_NOT_READY_TO_SEARCH,
- mainMonitor.split(47) // 47% of the time is spent in the dummy search
- );
- } catch (JavaModelException e) {
- // /search failed: ignore
- } catch (OperationCanceledException e) {
- if (mainMonitor.isCanceled())
- throw e;
- // else indexes were not ready: catch the exception so that jars are still refreshed
- }
+ // 47% of the time is spent in the dummy search
+ updateLegacyIndex(mainMonitor.split(47));
// check if the build state version number has changed since last session
// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=98969)
@@ -4342,6 +4328,41 @@
}
}
+ private static void updateLegacyIndex(IProgressMonitor monitor) {
+ SearchEngine engine = new SearchEngine();
+ IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
+ try {
+ engine.searchAllTypeNames(
+ null,
+ SearchPattern.R_EXACT_MATCH,
+ "!@$#!@".toCharArray(), //$NON-NLS-1$
+ SearchPattern.R_PATTERN_MATCH | SearchPattern.R_CASE_SENSITIVE,
+ IJavaSearchConstants.CLASS,
+ scope,
+ new TypeNameRequestor() {
+ public void acceptType(
+ int modifiers,
+ char[] packageName,
+ char[] simpleTypeName,
+ char[][] enclosingTypeNames,
+ String path) {
+ // no type to accept
+ }
+ },
+ // will not activate index query caches if indexes are not ready, since it would take to long
+ // to wait until indexes are fully rebuild
+ IJavaSearchConstants.CANCEL_IF_NOT_READY_TO_SEARCH,
+ monitor
+ );
+ } catch (JavaModelException e) {
+ // /search failed: ignore
+ } catch (OperationCanceledException e) {
+ if (monitor.isCanceled())
+ throw e;
+ // else indexes were not ready: catch the exception so that jars are still refreshed
+ }
+ }
+
/**
* Returns whether a given classpath variable is read-only or not.
*
@@ -5439,6 +5460,22 @@
JavaModelManager.getDeltaState().removePreResourceChangedListener(listener);
}
+ /**
+ * Deletes and rebuilds the java index.
+ *
+ * @param monitor a progress monitor, or <code>null</code> if progress
+ * reporting and cancellation are not desired
+ * @throws CoreException
+ * @since 3.13
+ */
+ public static void rebuildIndex(IProgressMonitor monitor) throws CoreException {
+ SubMonitor subMonitor = SubMonitor.convert(monitor, 10);
+ IndexManager manager = JavaModelManager.getIndexManager();
+ manager.deleteIndexFiles(subMonitor.split(1));
+ manager.reset();
+ Indexer.getInstance().rebuildIndex(subMonitor.split(7));
+ updateLegacyIndex(subMonitor.split(2));
+ }
/**
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java
index 1846d3f..c0ec076 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/core/Signature.java
@@ -1483,7 +1483,7 @@
}
return count;
} catch (ArrayIndexOutOfBoundsException e) { // signature is syntactically incorrect if last character is C_ARRAY
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
}
@@ -1626,7 +1626,7 @@
count++;
}
} catch (ArrayIndexOutOfBoundsException e) {
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
}
@@ -1680,7 +1680,7 @@
i = e + 1;
}
} catch (ArrayIndexOutOfBoundsException e) {
- throw new IllegalArgumentException();
+ throw new IllegalArgumentException(e);
}
}
/**
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaElementInfo.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaElementInfo.java
index 0250d5d..4de81cb 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaElementInfo.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaElementInfo.java
@@ -28,7 +28,7 @@
return super.clone();
}
catch (CloneNotSupportedException e) {
- throw new Error();
+ throw new Error(e);
}
}
public IJavaElement[] getChildren() {
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java
index b898a64..c250a8c 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaModelManager.java
@@ -27,6 +27,7 @@
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
+import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringReader;
@@ -173,7 +174,7 @@
private static final String ASSUMED_EXTERNAL_FILES_CACHE = "assumedExternalFilesCache"; //$NON-NLS-1$
public static enum ArchiveValidity {
- BAD_FORMAT, UNABLE_TO_READ, VALID;
+ BAD_FORMAT, UNABLE_TO_READ, FILE_NOT_FOUND, VALID;
public boolean isValid() {
return this == VALID;
@@ -2767,7 +2768,10 @@
* zip/jar, or it must be an absolute workspace relative path if
* representing a zip/jar inside the workspace.
*
- * @exception CoreException If unable to create/open the ZipFile
+ * @exception CoreException If unable to create/open the ZipFile. The
+ * cause will be a {@link ZipException} if the file was corrupt, a
+ * {@link FileNotFoundException} if the file does not exist, or a
+ * {@link IOException} if we were unable to read the file.
*/
public ZipFile getZipFile(IPath path) throws CoreException {
return getZipFile(path, true);
@@ -2782,7 +2786,7 @@
*/
public static boolean throwIoExceptionsInGetZipFile = false;
- private ZipFile getZipFile(IPath path, boolean checkInvalidArchiveCache) throws CoreException {
+ public ZipFile getZipFile(IPath path, boolean checkInvalidArchiveCache) throws CoreException {
if (checkInvalidArchiveCache) {
throwExceptionIfArchiveInvalid(path);
}
@@ -2807,7 +2811,15 @@
}
return zipFile;
} catch (IOException e) {
- ArchiveValidity reason = (e instanceof ZipException) ? ArchiveValidity.BAD_FORMAT : ArchiveValidity.UNABLE_TO_READ;
+ ArchiveValidity reason;
+
+ if (e instanceof ZipException) {
+ reason = ArchiveValidity.BAD_FORMAT;
+ } else if (e instanceof FileNotFoundException) {
+ reason = ArchiveValidity.FILE_NOT_FOUND;
+ } else {
+ reason = ArchiveValidity.UNABLE_TO_READ;
+ }
addInvalidArchive(path, reason);
throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, -1, Messages.status_IOException, e));
}
@@ -2835,13 +2847,14 @@
private void throwExceptionIfArchiveInvalid(IPath path) throws CoreException {
ArchiveValidity validity = getArchiveValidity(path);
- if (!validity.isValid()) {
- IOException reason;
- if (validity == ArchiveValidity.BAD_FORMAT) {
- reason = new ZipException();
- } else {
- reason = new IOException();
- }
+ IOException reason;
+ switch (validity) {
+ case BAD_FORMAT: reason = new ZipException(); break;
+ case FILE_NOT_FOUND: reason = new FileNotFoundException(); break;
+ case UNABLE_TO_READ: reason = new IOException(); break;
+ default: reason = null;
+ }
+ if (reason != null) {
throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, -1, Messages.status_IOException, reason));
}
}
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
index 02e6460..65dd9b5 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/JavaProject.java
@@ -913,9 +913,9 @@
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
cpElement = parser.parse(new InputSource(reader)).getDocumentElement();
} catch (SAXException e) {
- throw new IOException(Messages.file_badFormat);
+ throw new IOException(Messages.file_badFormat, e);
} catch (ParserConfigurationException e) {
- throw new IOException(Messages.file_badFormat);
+ throw new IOException(Messages.file_badFormat, e);
} finally {
reader.close();
}
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/UserLibrary.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/UserLibrary.java
index 13a38c3..f205707 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/UserLibrary.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/UserLibrary.java
@@ -154,9 +154,9 @@
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
cpElement = parser.parse(new InputSource(reader)).getDocumentElement();
} catch (SAXException e) {
- throw new IOException(Messages.file_badFormat);
+ throw new IOException(Messages.file_badFormat, e);
} catch (ParserConfigurationException e) {
- throw new IOException(Messages.file_badFormat);
+ throw new IOException(Messages.file_badFormat, e);
} finally {
reader.close();
}
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java
index 3097a43..26fb1c4 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/BatchImageBuilder.java
@@ -112,7 +112,11 @@
}
);
}
- member.delete(IResource.FORCE, null);
+ try {
+ member.delete(IResource.FORCE, null);
+ } catch(CoreException e) {
+ Util.log(e, "Error occurred while deleting: " + member.getFullPath()); //$NON-NLS-1$
+ }
}
}
this.notifier.checkCancel();
@@ -139,7 +143,11 @@
return false;
if (!resource.isDerived())
resource.setDerived(true, null);
- resource.delete(IResource.FORCE, null);
+ try {
+ resource.delete(IResource.FORCE, null);
+ } catch(CoreException e) {
+ Util.log(e, "Error occurred while deleting: " + resource.getFullPath()); //$NON-NLS-1$
+ }
}
return false;
}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/Nd.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/Nd.java
index fb02f13..f38304d 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/Nd.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/Nd.java
@@ -169,8 +169,8 @@
this.db.setLocked(lockDB);
if (!isSupportedVersion()) {
- Package.log("Index database is uses an unsupported version " + this.db.getVersion() //$NON-NLS-1$
- + " Deleting and recreating.", null); //$NON-NLS-1$
+ Package.logInfo("Index database uses the unsupported version " + this.db.getVersion() //$NON-NLS-1$
+ + ". Deleting and recreating."); //$NON-NLS-1$
this.db.close();
this.fPath.delete();
this.db = new Database(this.fPath, cache, getDefaultVersion(), isPermanentlyReadOnly());
@@ -599,4 +599,8 @@
public NdNodeTypeRegistry<NdNode> getTypeRegistry() {
return this.fNodeTypeRegistry;
}
+
+ public void clear(IProgressMonitor monitor) {
+ getDB().clear(getDefaultVersion());
+ }
}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/RawGrowableArray.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/RawGrowableArray.java
index df7ca4e..2bd371c 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/RawGrowableArray.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/RawGrowableArray.java
@@ -126,7 +126,7 @@
GROWABLE_BLOCK_HEADER_BYTES = type.size();
- MAX_GROWABLE_SIZE = (Database.MAX_MALLOC_SIZE - GROWABLE_BLOCK_HEADER_BYTES)
+ MAX_GROWABLE_SIZE = (Database.MAX_SINGLE_BLOCK_MALLOC_SIZE - GROWABLE_BLOCK_HEADER_BYTES)
/ Database.PTR_SIZE;
}
}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/Database.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/Database.java
index 02060fe..8bb0ed0 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/Database.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/Database.java
@@ -46,8 +46,9 @@
* INT_SIZE | pointer to head of linked list of blocks of size MIN_BLOCK_DELTAS*BLOCK_SIZE_DELTA
* .. | ...
* INT_SIZE * (M + 1) | pointer to head of linked list of blocks of size (M + MIN_BLOCK_DELTAS) * BLOCK_SIZE_DELTA
+ * FREE_BLOCK_OFFSET | chunk number for the root of the large block free space trie
* WRITE_NUMBER_OFFSET | long integer which is incremented on every write
- * MALLOC_STATS_OFFSET | memory usage statistics
+ * MALLOC_STATS_OFFSET | memory usage statistics
* DATA_AREA | The database singletons are stored here and use the remainder of chunk 0
*
* M = CHUNK_SIZE / BLOCK_SIZE_DELTA - MIN_BLOCK_DELTAS
@@ -86,21 +87,26 @@
private static final int BLOCK_PREV_OFFSET = BLOCK_HEADER_SIZE;
private static final int BLOCK_NEXT_OFFSET = BLOCK_HEADER_SIZE + INT_SIZE;
private static final int FREE_BLOCK_HEADER_SIZE = BLOCK_NEXT_OFFSET + INT_SIZE;
-
- public static final int MIN_BLOCK_DELTAS = (FREE_BLOCK_HEADER_SIZE + BLOCK_SIZE_DELTA - 1) /
- BLOCK_SIZE_DELTA; // Must be enough multiples of BLOCK_SIZE_DELTA in order to fit the free block header
- public static final int MAX_BLOCK_DELTAS = CHUNK_SIZE / BLOCK_SIZE_DELTA;
- public static final int MAX_MALLOC_SIZE = MAX_BLOCK_DELTAS * BLOCK_SIZE_DELTA - BLOCK_HEADER_SIZE;
- public static final int PTR_SIZE = 4; // size of a pointer in the database in bytes
+
+ // Must be enough multiples of BLOCK_SIZE_DELTA in order to fit the free block header
+ public static final int MIN_BLOCK_DELTAS = (FREE_BLOCK_HEADER_SIZE + BLOCK_SIZE_DELTA - 1) / BLOCK_SIZE_DELTA;
+ public static final int MAX_BLOCK_DELTAS = (CHUNK_SIZE - LargeBlock.HEADER_SIZE - LargeBlock.FOOTER_SIZE)
+ / BLOCK_SIZE_DELTA;
+ public static final int MAX_SINGLE_BLOCK_MALLOC_SIZE = MAX_BLOCK_DELTAS * BLOCK_SIZE_DELTA - BLOCK_HEADER_SIZE;
+ public static final int PTR_SIZE = 4; // size of a pointer in the database in bytes
public static final int STRING_SIZE = PTR_SIZE;
public static final int FLOAT_SIZE = INT_SIZE;
public static final int DOUBLE_SIZE = LONG_SIZE;
public static final long MAX_DB_SIZE= ((long) 1 << (Integer.SIZE + BLOCK_SIZE_DELTA_BITS));
+ public static final long MAX_MALLOC_SIZE = MAX_DB_SIZE - LargeBlock.HEADER_SIZE - LargeBlock.FOOTER_SIZE
+ - CHUNK_SIZE - BLOCK_HEADER_SIZE;
+
public static final int VERSION_OFFSET = 0;
- private static final int MALLOC_TABLE_OFFSET = VERSION_OFFSET + INT_SIZE;
- public static final int WRITE_NUMBER_OFFSET = MALLOC_TABLE_OFFSET
+ public static final int MALLOC_TABLE_OFFSET = VERSION_OFFSET + INT_SIZE;
+ public static final int FREE_BLOCK_OFFSET = MALLOC_TABLE_OFFSET
+ (CHUNK_SIZE / BLOCK_SIZE_DELTA - MIN_BLOCK_DELTAS + 1) * INT_SIZE;
+ public static final int WRITE_NUMBER_OFFSET = FREE_BLOCK_OFFSET + PTR_SIZE;
public static final int MALLOC_STATS_OFFSET = WRITE_NUMBER_OFFSET + LONG_SIZE;
public static final int DATA_AREA_OFFSET = MALLOC_STATS_OFFSET + MemoryStats.SIZE;
@@ -128,7 +134,6 @@
private final Chunk fHeaderChunk;
private Chunk[] fChunks;
private int fChunksUsed;
- private int fChunksAllocated;
private ChunkCache fCache;
private long malloced;
@@ -159,12 +164,12 @@
if (nChunksOnDisk <= 0) {
this.fVersion= version;
this.fChunks= new Chunk[1];
- this.fChunksUsed = this.fChunksAllocated = this.fChunks.length;
+ this.fChunksUsed = this.fChunks.length;
} else {
this.fHeaderChunk.read();
this.fVersion= this.fHeaderChunk.getInt(VERSION_OFFSET);
this.fChunks = new Chunk[nChunksOnDisk]; // chunk[0] is unused.
- this.fChunksUsed = this.fChunksAllocated = nChunksOnDisk;
+ this.fChunksUsed = nChunksOnDisk;
}
} catch (IOException e) {
throw new IndexException(new DBStatus(e));
@@ -172,8 +177,8 @@
this.memoryUsage = new MemoryStats(this.fHeaderChunk, MALLOC_STATS_OFFSET);
}
- private static int divideRoundingUp(int num, int den) {
- return (num + den - 1) / den;
+ private static int divideRoundingUp(long num, int den) {
+ return (int) ((num + den - 1) / den);
}
private void openFile() throws FileNotFoundException {
@@ -292,7 +297,7 @@
this.fHeaderChunk.clear(0, CHUNK_SIZE);
// Chunks have been removed from the cache, so we may just reset the array of chunks.
this.fChunks = new Chunk[] {null};
- this.fChunksUsed = this.fChunksAllocated = this.fChunks.length;
+ this.fChunksUsed = this.fChunks.length;
try {
wasCanceled = this.fHeaderChunk.flush() || wasCanceled; // Zero out header chunk.
wasCanceled = performUninterruptableWrite(() -> {
@@ -381,7 +386,7 @@
*/
public void memcpy(long dest, long source, int numBytes) {
assert numBytes >= 0;
- assert numBytes <= MAX_MALLOC_SIZE;
+ assert numBytes <= MAX_SINGLE_BLOCK_MALLOC_SIZE;
// TODO: make use of lower-level System.arrayCopy
for (int count = 0; count < numBytes; count++) {
putByte(dest + count, getByte(source + count));
@@ -391,78 +396,442 @@
/**
* Allocate a block out of the database.
*/
- public long malloc(final int datasize, final short poolId) throws IndexException {
+ public long malloc(final long datasize, final short poolId) throws IndexException {
assert this.fExclusiveLock;
assert datasize >= 0;
assert datasize <= MAX_MALLOC_SIZE;
- int needDeltas= divideRoundingUp(datasize + BLOCK_HEADER_SIZE, BLOCK_SIZE_DELTA);
- if (needDeltas < MIN_BLOCK_DELTAS) {
- needDeltas= MIN_BLOCK_DELTAS;
- }
-
- // Which block size.
- long freeblock = 0;
- int useDeltas;
- for (useDeltas= needDeltas; useDeltas <= MAX_BLOCK_DELTAS; useDeltas++) {
- freeblock = getFirstBlock(useDeltas * BLOCK_SIZE_DELTA);
- if (freeblock != 0)
- break;
- }
-
- // Get the block.
- Chunk chunk;
- if (freeblock == 0) {
- // Allocate a new chunk.
- freeblock= createNewChunk();
- useDeltas = MAX_BLOCK_DELTAS;
- chunk = getChunk(freeblock);
+ long result;
+ int usedSize;
+ if (datasize >= MAX_SINGLE_BLOCK_MALLOC_SIZE) {
+ int newChunkNum = createLargeBlock(datasize);
+ usedSize = Math.abs(getBlockHeaderForChunkNum(newChunkNum)) * CHUNK_SIZE;
+ result = newChunkNum * CHUNK_SIZE + LargeBlock.HEADER_SIZE;
+ // Note that we identify large blocks by setting their block size to 0.
+ clearRange(result, usedSize - LargeBlock.HEADER_SIZE - LargeBlock.FOOTER_SIZE);
+ result = result + BLOCK_HEADER_SIZE;
} else {
- chunk = getChunk(freeblock);
- removeBlock(chunk, useDeltas * BLOCK_SIZE_DELTA, freeblock);
+ long freeBlock = 0;
+ int needDeltas = divideRoundingUp(datasize + BLOCK_HEADER_SIZE, BLOCK_SIZE_DELTA);
+ if (needDeltas < MIN_BLOCK_DELTAS) {
+ needDeltas = MIN_BLOCK_DELTAS;
+ }
+
+ // Which block size.
+ int useDeltas;
+ for (useDeltas = needDeltas; useDeltas <= MAX_BLOCK_DELTAS; useDeltas++) {
+ freeBlock = getFirstBlock(useDeltas * BLOCK_SIZE_DELTA);
+ if (freeBlock != 0)
+ break;
+ }
+
+ // Get the block.
+ Chunk chunk;
+ if (freeBlock == 0) {
+ // Allocate a new chunk.
+ freeBlock = (long) (createLargeBlock(datasize)) * (long) CHUNK_SIZE + LargeBlock.HEADER_SIZE;
+ useDeltas = MAX_BLOCK_DELTAS;
+ chunk = getChunk(freeBlock);
+ } else {
+ chunk = getChunk(freeBlock);
+ removeBlock(chunk, useDeltas * BLOCK_SIZE_DELTA, freeBlock);
+ }
+
+ final int unusedDeltas = useDeltas - needDeltas;
+ if (unusedDeltas >= MIN_BLOCK_DELTAS) {
+ // Add in the unused part of our block.
+ addBlock(chunk, unusedDeltas * BLOCK_SIZE_DELTA, freeBlock + needDeltas * BLOCK_SIZE_DELTA);
+ useDeltas = needDeltas;
+ }
+
+ // Make our size negative to show in use.
+ usedSize = useDeltas * BLOCK_SIZE_DELTA;
+ chunk.putShort(freeBlock, (short) -usedSize);
+
+ // Clear out the block, lots of people are expecting this.
+ chunk.clear(freeBlock + BLOCK_HEADER_SIZE, usedSize - BLOCK_HEADER_SIZE);
+ result = freeBlock + BLOCK_HEADER_SIZE;
}
- final int unusedDeltas = useDeltas - needDeltas;
- if (unusedDeltas >= MIN_BLOCK_DELTAS) {
- // Add in the unused part of our block.
- addBlock(chunk, unusedDeltas * BLOCK_SIZE_DELTA, freeblock + needDeltas * BLOCK_SIZE_DELTA);
- useDeltas= needDeltas;
- }
-
- // Make our size negative to show in use.
- final int usedSize= useDeltas * BLOCK_SIZE_DELTA;
- chunk.putShort(freeblock, (short) -usedSize);
-
- // Clear out the block, lots of people are expecting this.
- chunk.clear(freeblock + BLOCK_HEADER_SIZE, usedSize - BLOCK_HEADER_SIZE);
-
this.malloced += usedSize;
- long result = freeblock + BLOCK_HEADER_SIZE;
this.memoryUsage.recordMalloc(poolId, usedSize);
return result;
}
- private long createNewChunk() throws IndexException {
+ /**
+ * Clears all the bytes in the given range by setting them to zero.
+ *
+ * @param startAddress first address to clear
+ * @param bytesToClear number of addresses to clear
+ */
+ public void clearRange(long startAddress, int bytesToClear) {
+ if (bytesToClear == 0) {
+ return;
+ }
+ long endAddress = startAddress + bytesToClear;
+ assert endAddress <= this.fChunksUsed * CHUNK_SIZE;
+ int blockNumber = (int) (startAddress / CHUNK_SIZE);
+ int firstBlockBytesToClear = Math.min((int) (((blockNumber + 1) * CHUNK_SIZE) - startAddress), bytesToClear);
+
+ Chunk firstBlock = getChunk(startAddress);
+ firstBlock.clear(startAddress, firstBlockBytesToClear);
+ startAddress += firstBlockBytesToClear;
+ bytesToClear -= firstBlockBytesToClear;
+ while (bytesToClear > CHUNK_SIZE) {
+ Chunk nextBlock = getChunk(startAddress);
+ nextBlock.clear(startAddress, CHUNK_SIZE);
+ startAddress += CHUNK_SIZE;
+ bytesToClear -= CHUNK_SIZE;
+ }
+
+ if (bytesToClear > 0) {
+ Chunk nextBlock = getChunk(startAddress);
+ nextBlock.clear(startAddress, bytesToClear);
+ }
+ }
+
+ /**
+ * Obtains a new block that can fit the given number of bytes (at minimum). Returns the
+ * chunk number.
+ *
+ * @param datasize minimum number of bytes needed
+ * @return the chunk number
+ */
+ private int createLargeBlock(long datasize) {
+ final int neededChunks = getChunksNeededForBytes(datasize);
+ int freeBlockChunkNum = getFreeBlockFromTrie(neededChunks);
+ final int numChunks;
+
+ if (freeBlockChunkNum == 0) {
+ final int lastChunkNum = this.fChunksUsed;
+
+ numChunks = neededChunks;
+
+ // Check if the last block in the database is free. If so, unlink and expand it.
+ int lastBlockSize = getBlockFooterForChunkBefore(lastChunkNum);
+ if (lastBlockSize > 0) {
+ int startChunkNum = getFirstChunkOfBlockBefore(lastChunkNum);
+
+ unlinkFreeBlock(startChunkNum);
+ // Allocate additional new chunks such that the new chunk is large enough to
+ // handle this allocation.
+ createNewChunks(neededChunks - lastBlockSize);
+ freeBlockChunkNum = startChunkNum;
+ } else {
+ freeBlockChunkNum = createNewChunks(numChunks);
+ }
+ } else {
+ numChunks = getBlockHeaderForChunkNum(freeBlockChunkNum);
+
+ unlinkFreeBlock(freeBlockChunkNum);
+ }
+
+ final int resultChunkNum;
+ if (numChunks > neededChunks) {
+ // If the chunk we've selected is larger than necessary, split it. We have the
+ // choice of using either half of the block. In the interest of leaving more
+ // opportunities of merging large blocks, we leave the unused half of the block
+ // next to the larger adjacent block.
+ final long nextBlockChunkNum = freeBlockChunkNum + numChunks;
+
+ final int nextBlockSize = Math.abs(getBlockHeaderForChunkNum(nextBlockChunkNum));
+ final int prevBlockSize = Math.abs(getBlockFooterForChunkBefore(freeBlockChunkNum));
+
+ final int unusedChunks = numChunks - neededChunks;
+ if (nextBlockSize >= prevBlockSize) {
+ // Use the start of the block
+ resultChunkNum = freeBlockChunkNum;
+ // Return the last half of the block to the free block pool
+ linkFreeBlockToTrie(freeBlockChunkNum + neededChunks, unusedChunks);
+ } else {
+ // Use the end of the block
+ resultChunkNum = freeBlockChunkNum + neededChunks;
+ // Return the first half of the block to the free block pool
+ linkFreeBlockToTrie(freeBlockChunkNum, unusedChunks);
+ }
+ } else {
+ resultChunkNum = freeBlockChunkNum;
+ }
+
+ // Fill in the header and footer
+ setBlockHeader(resultChunkNum, -neededChunks);
+ return resultChunkNum;
+ }
+
+ /**
+ * Unlinks a free block (which currently belongs to the free block trie) so that it may
+ * be reused.
+ *
+ * @param freeBlockChunkNum chunk number of the block to be unlinked
+ */
+ private void unlinkFreeBlock(int freeBlockChunkNum) {
+ long freeBlockAddress = freeBlockChunkNum * CHUNK_SIZE;
+ int anotherBlockOfSameSize = 0;
+ int nextBlockChunkNum = getInt(freeBlockAddress + LargeBlock.NEXT_BLOCK_OFFSET);
+ int prevBlockChunkNum = getInt(freeBlockAddress + LargeBlock.PREV_BLOCK_OFFSET);
+ // Relink the linked list
+ if (nextBlockChunkNum != 0) {
+ anotherBlockOfSameSize = nextBlockChunkNum;
+ putInt(nextBlockChunkNum * CHUNK_SIZE + LargeBlock.PREV_BLOCK_OFFSET, prevBlockChunkNum);
+ }
+ if (prevBlockChunkNum != 0) {
+ anotherBlockOfSameSize = prevBlockChunkNum;
+ putInt(prevBlockChunkNum * CHUNK_SIZE + LargeBlock.NEXT_BLOCK_OFFSET, nextBlockChunkNum);
+ }
+
+ long root = getInt(FREE_BLOCK_OFFSET);
+ if (root == freeBlockChunkNum) {
+ putInt(FREE_BLOCK_OFFSET, 0);
+ }
+
+ int freeBlockSize = getBlockHeaderForChunkNum(freeBlockChunkNum);
+ int parentChunkNum = getInt(freeBlockAddress + LargeBlock.PARENT_OFFSET);
+ if (parentChunkNum != 0) {
+ int currentSize = getBlockHeaderForChunkNum(parentChunkNum);
+ int difference = currentSize ^ freeBlockSize;
+ if (difference != 0) {
+ int firstDifference = LargeBlock.SIZE_OF_SIZE_FIELD * 8 - Integer.numberOfLeadingZeros(difference) - 1;
+ long locationOfChildPointer = parentChunkNum * CHUNK_SIZE + LargeBlock.CHILD_TABLE_OFFSET
+ + (firstDifference * INT_SIZE);
+ putInt(locationOfChildPointer, 0);
+ }
+ }
+
+ if (anotherBlockOfSameSize != 0) {
+ insertChild(parentChunkNum, anotherBlockOfSameSize);
+ }
+
+ int currentParent = parentChunkNum;
+ for (int childIdx = 0; childIdx < LargeBlock.ENTRIES_IN_CHILD_TABLE; childIdx++) {
+ int nextChildChunkNum = getInt(freeBlockAddress + LargeBlock.CHILD_TABLE_OFFSET + (childIdx * INT_SIZE));
+ if (nextChildChunkNum != 0) {
+ insertChild(currentParent, nextChildChunkNum);
+ // Parent all subsequent children under the child that was most similar to the old parent
+ if (currentParent == parentChunkNum) {
+ currentParent = nextChildChunkNum;
+ }
+ }
+ }
+
+ }
+
+ /**
+ * Returns the chunk number of a free block that contains at least the given number of chunks, or
+ * 0 if there is no existing contiguous free block containing at least the given number of chunks.
+ *
+ * @param numChunks minumum number of chunks desired
+ * @return the chunk number of a free block containing at least the given number of chunks or 0
+ * if there is no existing free block containing that many chunks.
+ */
+ private int getFreeBlockFromTrie(int numChunks) {
+ int currentChunkNum = getInt(FREE_BLOCK_OFFSET);
+
+ int resultChunkNum = getSmallestChildNoSmallerThan(currentChunkNum, numChunks);
+ if (resultChunkNum == 0) {
+ return 0;
+ }
+
+ // Try not to return the trie node itself if there is a linked list entry available, since unlinking
+ // something from the linked list is faster than unlinking a trie node.
+ int nextResultChunkNum = getInt(resultChunkNum * CHUNK_SIZE + LargeBlock.NEXT_BLOCK_OFFSET);
+ if (nextResultChunkNum != 0) {
+ return nextResultChunkNum;
+ }
+ return resultChunkNum;
+ }
+
+ /**
+ * Given the chunk number of a block somewhere in the free space trie, this returns the smallest
+ * child in the subtree that is no smaller than the given number of chunks.
+ *
+ * @param trieNodeChunkNum chunk number of a block in the free space trie
+ * @param numChunks desired number of chunks
+ * @return the chunk number of the first chunk in a contiguous free block containing at least the
+ * given number of chunks
+ */
+ private int getSmallestChildNoSmallerThan(int trieNodeChunkNum, int numChunks) {
+ if (trieNodeChunkNum == 0) {
+ return 0;
+ }
+ int currentSize = getBlockHeaderForChunkNum(trieNodeChunkNum);
+ assert (currentSize >= 0);
+ int difference = currentSize ^ numChunks;
+ if (difference == 0) {
+ return trieNodeChunkNum;
+ }
+
+ int bitMask = Integer.highestOneBit(difference);
+ int firstDifference = LargeBlock.SIZE_OF_SIZE_FIELD * 8 - Integer.numberOfLeadingZeros(bitMask) - 1;
+ boolean lookingForSmallerChild = (currentSize > numChunks);
+ for (int testPosition = firstDifference; testPosition < LargeBlock.ENTRIES_IN_CHILD_TABLE; testPosition++) {
+ if (((currentSize & bitMask) != 0) == lookingForSmallerChild) {
+ int nextChildChunkNum = getInt(
+ trieNodeChunkNum * CHUNK_SIZE + LargeBlock.CHILD_TABLE_OFFSET + (testPosition * PTR_SIZE));
+ int childResultChunkNum = getSmallestChildNoSmallerThan(nextChildChunkNum, numChunks);
+ if (childResultChunkNum != 0) {
+ return childResultChunkNum;
+ }
+ }
+ bitMask <<= 1;
+ }
+
+ if (lookingForSmallerChild) {
+ return trieNodeChunkNum;
+ } else {
+ return 0;
+ }
+ }
+
+ /**
+ * Link the given unused block into the free block tries. The block does not need to have
+ * its header filled in already.
+ *
+ * @param freeBlockChunkNum chunk number of the start of the block
+ * @param numChunks number of chunks in the block
+ */
+ private void linkFreeBlockToTrie(int freeBlockChunkNum, int numChunks) {
+ setBlockHeader(freeBlockChunkNum, numChunks);
+ long freeBlockAddress = freeBlockChunkNum * CHUNK_SIZE;
+ Chunk chunk = getChunk(freeBlockAddress);
+ chunk.clear(freeBlockAddress + LargeBlock.HEADER_SIZE,
+ LargeBlock.UNALLOCATED_HEADER_SIZE - LargeBlock.HEADER_SIZE);
+
+ insertChild(getInt(FREE_BLOCK_OFFSET), freeBlockChunkNum);
+ }
+
+ /**
+ * Adds the given child block to the given parent subtree of the free space trie. Any existing
+ * subtree under the given child block will be retained.
+ *
+ * @param parentChunkNum root of the existing tree, or 0 if the child is going to be the new root
+ * @param newChildChunkNum the new child to insert
+ */
+ private void insertChild(int parentChunkNum, int newChildChunkNum) {
+ if (parentChunkNum == 0) {
+ putInt(newChildChunkNum * CHUNK_SIZE + LargeBlock.PARENT_OFFSET, parentChunkNum);
+ putInt(FREE_BLOCK_OFFSET, newChildChunkNum);
+ return;
+ }
+ int numChunks = getBlockHeaderForChunkNum(newChildChunkNum);
+ for (;;) {
+ int currentSize = getBlockHeaderForChunkNum(parentChunkNum);
+ int difference = currentSize ^ numChunks;
+ if (difference == 0) {
+ // The newly added item is exactly the same size as this trie node
+ insertFreeBlockAfter(parentChunkNum, newChildChunkNum);
+ return;
+ }
+
+ int firstDifference = LargeBlock.SIZE_OF_SIZE_FIELD * 8 - Integer.numberOfLeadingZeros(difference) - 1;
+ long locationOfChildPointer = parentChunkNum * CHUNK_SIZE + LargeBlock.CHILD_TABLE_OFFSET
+ + (firstDifference * INT_SIZE);
+ int childChunkNum = getInt(locationOfChildPointer);
+ if (childChunkNum == 0) {
+ putInt(locationOfChildPointer, newChildChunkNum);
+ putInt(newChildChunkNum * CHUNK_SIZE + LargeBlock.PARENT_OFFSET, parentChunkNum);
+ return;
+ }
+ parentChunkNum = childChunkNum;
+ }
+ }
+
+ /**
+ * Adds the given block to the linked list of equally-sized free chunks in the free space trie.
+ * Both chunks must be unused, must be the same size, and the previous chunk must already
+ * be linked into the free space trie. The newly-added chunk must not have any children.
+ *
+ * @param prevChunkNum chunk number of previous block in the existing list
+ * @param newChunkNum new chunk to be added to the list
+ */
+ private void insertFreeBlockAfter(int prevChunkNum, int newChunkNum) {
+ long prevChunkAddress = (long) prevChunkNum * CHUNK_SIZE;
+ int nextChunkNum = getInt(prevChunkAddress + LargeBlock.NEXT_BLOCK_OFFSET);
+ long nextChunkAddress = (long) nextChunkNum * CHUNK_SIZE;
+ long newLockAddress = (long) newChunkNum * CHUNK_SIZE;
+
+ putInt(prevChunkAddress + LargeBlock.NEXT_BLOCK_OFFSET, newChunkNum);
+ if (nextChunkNum != 0) {
+ putInt(nextChunkAddress + LargeBlock.PREV_BLOCK_OFFSET, newChunkNum);
+ }
+ putInt(newLockAddress + LargeBlock.PREV_BLOCK_OFFSET, prevChunkNum);
+ putInt(newLockAddress + LargeBlock.NEXT_BLOCK_OFFSET, nextChunkNum);
+ }
+
+ /**
+ * Returns the chunk number of the chunk at the start of a block, given the
+ * chunk number of the chunk at the start of the following block.
+ *
+ * @param chunkNum the chunk number of the chunk immediately following the
+ * chunk being queried
+ * @return the chunk number of the chunk at the start of the previous block
+ */
+ private int getFirstChunkOfBlockBefore(int chunkNum) {
+ int blockChunks = Math.abs(getBlockFooterForChunkBefore(chunkNum));
+ return chunkNum - blockChunks;
+ }
+
+ /**
+ * Sets the block header and footer for the given range of chunks which make
+ * up a contiguous block.
+ *
+ * @param firstChunkNum chunk number of the first chunk in the block
+ * @param headerContent the content of the header. Its magnitude is the number of
+ * chunks in the block. It is positive if the chunk is free and negative if
+ * the chunk is in use.
+ */
+ private void setBlockHeader(int firstChunkNum, int headerContent) {
+ assert headerContent != 0;
+ assert firstChunkNum < this.fChunksUsed;
+ int numBlocks = Math.abs(headerContent);
+ long firstChunkAddress = firstChunkNum * CHUNK_SIZE;
+ putInt(firstChunkAddress, headerContent);
+ putInt(firstChunkAddress + (numBlocks * CHUNK_SIZE) - LargeBlock.FOOTER_SIZE, headerContent);
+ }
+
+ /**
+ * Returns the size of the block (in number of chunks) starting at the given address. The return value is positive
+ * if the block is free and negative if the block is allocated.
+ */
+ private int getBlockHeaderForChunkNum(long firstChunkNum) {
+ if (firstChunkNum >= this.fChunksUsed) {
+ return 0;
+ }
+ return getInt(firstChunkNum * CHUNK_SIZE);
+ }
+
+ /**
+ * Returns the size of the block (in number of chunks), given the (non-inclusive) address that the block ends at.
+ * The return value is positive if the block is free and negative if the block is allocated.
+ */
+ private int getBlockFooterForChunkBefore(int chunkNum) {
+ if (chunkNum < 2) {
+ // Don't report the database header as a normal chunk.
+ return 0;
+ }
+ return getInt(chunkNum * CHUNK_SIZE - LargeBlock.FOOTER_SIZE);
+ }
+
+ private int createNewChunks(int numChunks) throws IndexException {
assert this.fExclusiveLock;
synchronized (this.fCache) {
- final int newChunkIndex = this.fChunksUsed; // fChunks.length;
+ final int firstChunkIndex = this.fChunksUsed;
+ final int lastChunkIndex = firstChunkIndex + numChunks - 1;
- final Chunk chunk = new Chunk(this, newChunkIndex);
- chunk.fDirty = true;
+ final Chunk lastChunk = new Chunk(this, lastChunkIndex);
+ lastChunk.fDirty = true;
- if (newChunkIndex >= this.fChunksAllocated) {
- int increment = Math.max(1024, this.fChunksAllocated / 20);
- Chunk[] newchunks = new Chunk[this.fChunksAllocated + increment];
- System.arraycopy(this.fChunks, 0, newchunks, 0, this.fChunksAllocated);
-
- this.fChunks = newchunks;
- this.fChunksAllocated += increment;
+ if (lastChunkIndex >= this.fChunks.length) {
+ int increment = Math.max(1024, this.fChunks.length / 20);
+ int newNumChunks = Math.max(lastChunkIndex + 1, this.fChunks.length + increment);
+ Chunk[] newChunks = new Chunk[newNumChunks];
+ System.arraycopy(this.fChunks, 0, newChunks, 0, this.fChunks.length);
+ this.fChunks = newChunks;
}
- this.fChunksUsed += 1;
- this.fChunks[newChunkIndex] = chunk;
- this.fCache.add(chunk, true);
- long address = (long) newChunkIndex * CHUNK_SIZE;
+ this.fChunksUsed = lastChunkIndex + 1;
+ this.fChunks[lastChunkIndex] = lastChunk;
+ this.fCache.add(lastChunk, true);
+ long result = (long) firstChunkIndex * CHUNK_SIZE;
/*
* Non-dense pointers are at most 31 bits dense pointers are at most 35 bits Check the sizes here and throw
@@ -470,33 +839,15 @@
* indexing operation should be stopped. This is desired since generally, once the max size is exceeded,
* there are lots of errors.
*/
- if (address >= MAX_DB_SIZE) {
+ long endAddress = result + (numChunks * CHUNK_SIZE);
+ if (endAddress > MAX_DB_SIZE) {
Object bindings[] = { this.getLocation().getAbsolutePath(), MAX_DB_SIZE };
throw new IndexException(new Status(IStatus.ERROR, Package.PLUGIN_ID, Package.STATUS_DATABASE_TOO_LARGE,
- NLS.bind("Database too large! Address = " + address + ", max size = " + MAX_DB_SIZE, bindings), //$NON-NLS-1$ //$NON-NLS-2$
- null));
+ NLS.bind("Database too large! Address = " + endAddress + ", max size = " + MAX_DB_SIZE, //$NON-NLS-1$ //$NON-NLS-2$
+ bindings), null));
}
- return address;
- }
- }
- /**
- * For testing purposes, only.
- */
- private long createNewChunks(int numChunks) throws IndexException {
- assert this.fExclusiveLock;
- synchronized (this.fCache) {
- final int oldLen= this.fChunks.length;
- Chunk[] newchunks = new Chunk[oldLen + numChunks];
- System.arraycopy(this.fChunks, 0, newchunks, 0, oldLen);
- final Chunk chunk= new Chunk(this, oldLen + numChunks - 1);
- chunk.fDirty= true;
- newchunks[ oldLen + numChunks - 1 ] = chunk;
- this.fChunks= newchunks;
- this.fCache.add(chunk, true);
- this.fChunksAllocated=oldLen + numChunks;
- this.fChunksUsed=oldLen + numChunks;
- return (long) (oldLen + numChunks - 1) * CHUNK_SIZE;
+ return firstChunkIndex;
}
}
@@ -544,26 +895,74 @@
/**
* Free an allocated block.
*
- * @param address memory address to be freed
- * @param poolId the same ID that was previously passed into malloc when allocating this memory address
+ * @param address
+ * memory address to be freed
+ * @param poolId
+ * the same ID that was previously passed into malloc when allocating this memory address
*/
public void free(long address, short poolId) throws IndexException {
assert this.fExclusiveLock;
if (address == 0) {
return;
}
- // TODO Look for opportunities to merge blocks
+ long blockSize;
long block = address - BLOCK_HEADER_SIZE;
Chunk chunk = getChunk(block);
- int blocksize = - chunk.getShort(block);
- if (blocksize < 0) {
- // Already freed.
- throw new IndexException(new Status(IStatus.ERROR, Package.PLUGIN_ID, 0,
- "Already freed record " + address, new Exception())); //$NON-NLS-1$
+ blockSize = -chunk.getShort(block);
+ // We use a block size of 0 to indicate a large block that fills a range of chunks
+ if (blockSize == 0) {
+ int offsetIntoChunk = (int) (address % CHUNK_SIZE);
+ assert offsetIntoChunk == LargeBlock.HEADER_SIZE + BLOCK_HEADER_SIZE;
+ // Deallocating a large block
+ // This was a large block. It uses a sequence of full chunks.
+ int chunkNum = (int) (address / CHUNK_SIZE);
+ int numChunks = -getBlockHeaderForChunkNum(chunkNum);
+ if (numChunks < 0) {
+ // Already freed.
+ throw new IndexException(new Status(IStatus.ERROR, Package.PLUGIN_ID, 0,
+ "Already freed large block " + address, new Exception())); //$NON-NLS-1$
+ }
+ blockSize = numChunks * CHUNK_SIZE;
+ freeLargeChunk(chunkNum, numChunks);
+ } else {
+ // Deallocating a normal block
+ // TODO Look for opportunities to merge small blocks
+ if (blockSize < 0) {
+ // Already freed.
+ throw new IndexException(new Status(IStatus.ERROR, Package.PLUGIN_ID, 0,
+ "Already freed record " + address, new Exception())); //$NON-NLS-1$
+ }
+ addBlock(chunk, (int) blockSize, block);
}
- addBlock(chunk, blocksize, block);
- this.freed += blocksize;
- this.memoryUsage.recordFree(poolId, blocksize);
+
+ this.freed += blockSize;
+ this.memoryUsage.recordFree(poolId, blockSize);
+ }
+
+ private void freeLargeChunk(int chunkNum, int numChunks) {
+ assert chunkNum > 0;
+ assert numChunks > 0;
+ int prevBlockHeader = getBlockFooterForChunkBefore(chunkNum);
+ int nextBlockChunkNum = chunkNum + numChunks;
+ int nextBlockHeader = getBlockHeaderForChunkNum(nextBlockChunkNum);
+
+ // If the previous block is unused, merge with it
+ if (prevBlockHeader > 0) {
+ int prevBlockChunkNum = getFirstChunkOfBlockBefore(chunkNum);
+
+ unlinkFreeBlock(prevBlockChunkNum);
+ chunkNum = prevBlockChunkNum;
+ numChunks += prevBlockHeader;
+ }
+
+ // If the next block is unused, merge with it
+ if (nextBlockHeader > 0) {
+ unlinkFreeBlock(nextBlockChunkNum);
+ numChunks += nextBlockHeader;
+ }
+
+ // Block merging is done. Now reinsert the merged block into the free space trie
+ linkFreeBlockToTrie(chunkNum, numChunks);
}
public void putByte(long offset, byte value) throws IndexException {
@@ -745,7 +1144,7 @@
this.memoryUsage.refresh();
this.fHeaderChunk.fDirty= false;
this.fChunks= new Chunk[] { null };
- this.fChunksUsed = this.fChunksAllocated = this.fChunks.length;
+ this.fChunksUsed = this.fChunks.length;
try {
this.fFile.close();
} catch (IOException e) {
@@ -931,6 +1330,10 @@
return this.fFile.length();
}
+ public int getChunkCount() {
+ return this.fChunksUsed;
+ }
+
/**
* A Record Pointer is a pointer as returned by Database.malloc().
* This is a pointer to a block + BLOCK_HEADER_SIZE.
@@ -953,4 +1356,19 @@
public MemoryStats getMemoryStats() {
return this.memoryUsage;
}
+
+ /**
+ * Returns the number of bytes that can fit in the payload of the given number of chunks.
+ */
+ public static long getBytesThatFitInChunks(int numChunks) {
+ return CHUNK_SIZE * numChunks - LargeBlock.HEADER_SIZE - LargeBlock.FOOTER_SIZE - BLOCK_HEADER_SIZE;
+ }
+
+ /**
+ * Returns the number of chunks needed to fit the given number of bytes of payload.
+ */
+ public static int getChunksNeededForBytes(long datasize) {
+ return divideRoundingUp(datasize + BLOCK_HEADER_SIZE + LargeBlock.HEADER_SIZE + LargeBlock.FOOTER_SIZE,
+ CHUNK_SIZE);
+ }
}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/LargeBlock.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/LargeBlock.java
new file mode 100644
index 0000000..26af53c
--- /dev/null
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/LargeBlock.java
@@ -0,0 +1,26 @@
+package org.eclipse.jdt.internal.core.nd.db;
+
+public class LargeBlock {
+ public static final int SIZE_OFFSET = 0;
+ public static final int SIZE_OF_SIZE_FIELD = Database.INT_SIZE;
+ /**
+ * Size of the header for a large block. The header consists of a int which holds the number of chunks in the block.
+ * It is negative for an allocated block and positive for an unallocated block. The header is located at the start
+ * of the large block.
+ */
+ public static final int HEADER_SIZE = Math.max(Database.INT_SIZE, Database.BLOCK_SIZE_DELTA);
+
+ public static final int ENTRIES_IN_CHILD_TABLE = SIZE_OF_SIZE_FIELD * 8;
+ public static final int CHILD_TABLE_OFFSET = HEADER_SIZE;
+ public static final int PARENT_OFFSET = CHILD_TABLE_OFFSET + (Database.INT_SIZE * ENTRIES_IN_CHILD_TABLE);
+ public static final int PREV_BLOCK_OFFSET = PARENT_OFFSET + Database.INT_SIZE;
+ public static final int NEXT_BLOCK_OFFSET = PREV_BLOCK_OFFSET + Database.INT_SIZE;
+
+ public static final int UNALLOCATED_HEADER_SIZE = NEXT_BLOCK_OFFSET + Database.INT_SIZE;
+
+ /**
+ * The large block footer is located at the end of the last chunk in the large block. It is an exact copy of the
+ * header.
+ */
+ public static final int FOOTER_SIZE = HEADER_SIZE;
+}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/LongString.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/LongString.java
index c78b7f9..eb0e48a 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/LongString.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/LongString.java
@@ -29,13 +29,13 @@
private static final int NEXT1 = 4;
private static final int CHARS1 = 8;
- private static final int NUM_CHARS1 = (Database.MAX_MALLOC_SIZE - CHARS1) / 2;
+ private static final int NUM_CHARS1 = (Database.MAX_SINGLE_BLOCK_MALLOC_SIZE - CHARS1) / 2;
// Additional fields of subsequent records.
private static final int NEXTN = 0;
private static final int CHARSN = 4;
- private static final int NUM_CHARSN = (Database.MAX_MALLOC_SIZE - CHARSN) / 2;
+ private static final int NUM_CHARSN = (Database.MAX_SINGLE_BLOCK_MALLOC_SIZE - CHARSN) / 2;
public LongString(Database db, long record) {
this.db = db;
@@ -47,7 +47,7 @@
final int numCharsn = useBytes ? NUM_CHARSN * 2 : NUM_CHARSN;
this.db = db;
- this.record = db.malloc(Database.MAX_MALLOC_SIZE, Database.POOL_STRING_LONG);
+ this.record = db.malloc(Database.MAX_SINGLE_BLOCK_MALLOC_SIZE, Database.POOL_STRING_LONG);
// Write the first record.
final int length = chars.length;
@@ -64,7 +64,7 @@
long lastNext = this.record + NEXT1;
int start = numChars1;
while (length - start > numCharsn) {
- long nextRecord = db.malloc(Database.MAX_MALLOC_SIZE, Database.POOL_STRING_LONG);
+ long nextRecord = db.malloc(Database.MAX_SINGLE_BLOCK_MALLOC_SIZE, Database.POOL_STRING_LONG);
db.putRecPtr(lastNext, nextRecord);
chunk= db.getChunk(nextRecord);
if (useBytes) {
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/ShortString.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/ShortString.java
index 09992a5..eb56c6c 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/ShortString.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/db/ShortString.java
@@ -25,7 +25,7 @@
private static final int LENGTH = 0;
private static final int CHARS = 4;
- public static final int MAX_BYTE_LENGTH = Database.MAX_MALLOC_SIZE - CHARS;
+ public static final int MAX_BYTE_LENGTH = Database.MAX_SINGLE_BLOCK_MALLOC_SIZE - CHARS;
public ShortString(Database db, long offset) {
this.db = db;
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/ClassFileToIndexConverter.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/ClassFileToIndexConverter.java
index afd740e..d52ce33 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/ClassFileToIndexConverter.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/ClassFileToIndexConverter.java
@@ -16,9 +16,7 @@
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.compiler.CharOperation;
-import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
import org.eclipse.jdt.internal.compiler.codegen.AnnotationTargetTypeConstants;
import org.eclipse.jdt.internal.compiler.env.ClassSignature;
import org.eclipse.jdt.internal.compiler.env.EnumConstantSignature;
@@ -69,8 +67,6 @@
import org.eclipse.jdt.internal.core.nd.java.NdTypeParameter;
import org.eclipse.jdt.internal.core.nd.java.NdTypeSignature;
import org.eclipse.jdt.internal.core.nd.java.NdVariable;
-import org.eclipse.jdt.internal.core.nd.java.model.BinaryTypeDescriptor;
-import org.eclipse.jdt.internal.core.nd.java.model.BinaryTypeFactory;
import org.eclipse.jdt.internal.core.nd.util.CharArrayUtils;
import org.eclipse.jdt.internal.core.util.CharArrayBuffer;
import org.eclipse.jdt.internal.core.util.Util;
@@ -97,12 +93,6 @@
return this.resource.getNd();
}
- public static IBinaryType getTypeFromClassFile(IClassFile iClassFile, IProgressMonitor monitor)
- throws CoreException, ClassFormatException {
- BinaryTypeDescriptor descriptor = BinaryTypeFactory.createDescriptor(iClassFile);
- return BinaryTypeFactory.rawReadType(descriptor, true);
- }
-
/**
* Create a type info from the given class file in a jar and adds it to the given list of infos.
*
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/Indexer.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/Indexer.java
index 318a736..2380780 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/Indexer.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/indexer/Indexer.java
@@ -10,7 +10,7 @@
*******************************************************************************/
package org.eclipse.jdt.internal.core.nd.indexer;
-import java.io.File;
+import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
@@ -43,6 +43,7 @@
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.core.runtime.jobs.JobGroup;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
@@ -115,10 +116,16 @@
*/
private Set<Listener> listeners = Collections.newSetFromMap(new WeakHashMap<Listener, Boolean>());
+ private JobGroup group = new JobGroup(Messages.Indexer_updating_index_job_name, 1, 1);
+
private Job rescanJob = Job.create(Messages.Indexer_updating_index_job_name, monitor -> {
rescan(monitor);
});
+ private Job rebuildIndexJob = Job.create(Messages.Indexer_updating_index_job_name, monitor -> {
+ rebuildIndex(monitor);
+ });
+
public static interface Listener {
void consume(IndexerEvent event);
}
@@ -560,14 +567,6 @@
String pathString = thePath.toString();
JavaIndex javaIndex = JavaIndex.getIndex(this.nd);
- File theFile = thePath.toFile();
- if (!(theFile.exists() && theFile.isFile())) {
- if (DEBUG) {
- Package.log("the file " + pathString + " does not exist", null); //$NON-NLS-1$ //$NON-NLS-2$
- }
- return 0;
- }
-
NdResourceFile resourceFile;
this.nd.acquireWriteLock(subMonitor.split(5));
@@ -589,9 +588,11 @@
if (DEBUG) {
Package.logInfo("rescanning " + thePath.toString() + ", " + fingerprint); //$NON-NLS-1$ //$NON-NLS-2$
}
- int result;
+ int result = 0;
try {
- result = addElement(resourceFile, element, subMonitor.split(50));
+ if (fingerprint.fileExists()) {
+ result = addElement(resourceFile, element, subMonitor.split(50));
+ }
} catch (JavaModelException e) {
if (DEBUG) {
Package.log("the file " + pathString + " cannot be indexed due to a recoverable error", null); //$NON-NLS-1$ //$NON-NLS-2$
@@ -611,6 +612,12 @@
Package.log("A RuntimeException occurred while indexing " + pathString, e); //$NON-NLS-1$
}
throw e;
+ } catch (FileNotFoundException e) {
+ fingerprint = FileFingerprint.getEmpty();
+ }
+
+ if (DEBUG && !fingerprint.fileExists()) {
+ Package.log("the file " + pathString + " was not indexed because it does not exist", null); //$NON-NLS-1$ //$NON-NLS-2$
}
List<NdResourceFile> allResourcesWithThisPath = Collections.emptyList();
@@ -648,9 +655,10 @@
/**
* Adds an archive to the index, under the given NdResourceFile.
+ * @throws FileNotFoundException if the file does not exist
*/
private int addElement(NdResourceFile resourceFile, IJavaElement element, IProgressMonitor monitor)
- throws JavaModelException {
+ throws JavaModelException, FileNotFoundException {
SubMonitor subMonitor = SubMonitor.convert(monitor);
if (element instanceof JarPackageFragmentRoot) {
@@ -704,6 +712,8 @@
} catch (ZipException e) {
Package.log("The zip file " + jarRoot.getPath() + " was corrupt", e); //$NON-NLS-1$//$NON-NLS-2$
// Indicates a corrupt zip file. Treat this like an empty zip file.
+ } catch (FileNotFoundException e) {
+ throw e;
} catch (IOException ioException) {
throw new JavaModelException(ioException, IJavaModelStatusConstants.IO_EXCEPTION);
} catch (CoreException coreException) {
@@ -722,7 +732,7 @@
boolean indexed = false;
try {
- ClassFileReader classFileReader = BinaryTypeFactory.rawReadType(descriptor, true);
+ ClassFileReader classFileReader = BinaryTypeFactory.rawReadTypeTestForExists(descriptor, true, false);
if (classFileReader != null) {
indexed = addClassToIndex(resourceFile, descriptor.fieldDescriptor, descriptor.indexPath,
classFileReader, iterationMonitor);
@@ -983,6 +993,10 @@
public Indexer(Nd toPopulate, IWorkspaceRoot workspaceRoot) {
this.nd = toPopulate;
this.root = workspaceRoot;
+ this.rescanJob.setSystem(true);
+ this.rescanJob.setJobGroup(this.group);
+ this.rebuildIndexJob.setSystem(true);
+ this.rebuildIndexJob.setJobGroup(this.group);
}
public void rescanAll() {
@@ -1070,4 +1084,20 @@
}
}
}
+
+ public void rebuildIndex(IProgressMonitor monitor) throws CoreException {
+ SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
+
+ this.nd.acquireWriteLock(subMonitor.split(1));
+ try {
+ this.nd.clear(subMonitor.split(2));
+ } finally {
+ this.nd.releaseWriteLock();
+ }
+ rescan(subMonitor.split(98));
+ }
+
+ public void requestRebuildIndex() {
+ this.rebuildIndexJob.schedule();
+ }
}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/FileFingerprint.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/FileFingerprint.java
index f1b0262..b5d6062 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/FileFingerprint.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/FileFingerprint.java
@@ -139,6 +139,15 @@
}
/**
+ * Returns true iff the file existed at the time the fingerprint was computed.
+ *
+ * @return true iff the file existed at the time the fingerprint was computed.
+ */
+ public boolean fileExists() {
+ return !equals(EMPTY);
+ }
+
+ /**
* Compares the given File with the receiver. If the fingerprint matches (ie: the file
*/
public FingerprintTestResult test(IPath path, IProgressMonitor monitor) throws CoreException {
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/JavaIndex.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/JavaIndex.java
index 006aeff..778d5da 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/JavaIndex.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/JavaIndex.java
@@ -34,9 +34,9 @@
public class JavaIndex {
// Version constants
- static final int CURRENT_VERSION = Nd.version(1, 37);
- static final int MAX_SUPPORTED_VERSION = Nd.version(1, 37);
- static final int MIN_SUPPORTED_VERSION = Nd.version(1, 37);
+ static final int CURRENT_VERSION = Nd.version(1, 38);
+ static final int MAX_SUPPORTED_VERSION = Nd.version(1, 38);
+ static final int MIN_SUPPORTED_VERSION = Nd.version(1, 38);
// Fields for the search header
public static final FieldSearchIndex<NdResourceFile> FILES;
@@ -293,8 +293,4 @@
registry.register(0x0200, NdWorkspaceLocation.type.getFactory());
return registry;
}
-
- public void rebuildIndex() {
- // TODO: delete and recreate the index
- }
}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/model/BinaryTypeFactory.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/model/BinaryTypeFactory.java
index d6d3981..631c384 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/model/BinaryTypeFactory.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/model/BinaryTypeFactory.java
@@ -10,15 +10,19 @@
*******************************************************************************/
package org.eclipse.jdt.internal.core.nd.java.model;
+import java.io.FileNotFoundException;
import java.io.IOException;
+import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IJavaElement;
@@ -37,6 +41,7 @@
import org.eclipse.jdt.internal.core.nd.IReader;
import org.eclipse.jdt.internal.core.nd.Nd;
import org.eclipse.jdt.internal.core.nd.db.IndexException;
+import org.eclipse.jdt.internal.core.nd.indexer.Indexer;
import org.eclipse.jdt.internal.core.nd.java.JavaIndex;
import org.eclipse.jdt.internal.core.nd.java.JavaNames;
import org.eclipse.jdt.internal.core.nd.java.NdResourceFile;
@@ -111,9 +116,8 @@
* no such type exists.
* @throws ClassFormatException
*/
- public static IBinaryType readType(BinaryTypeDescriptor descriptor,
- IProgressMonitor monitor) throws JavaModelException, ClassFormatException {
-
+ public static IBinaryType readType(BinaryTypeDescriptor descriptor, IProgressMonitor monitor) throws JavaModelException, ClassFormatException {
+
if (JavaIndex.isEnabled()) {
try {
return readFromIndex(JavaIndex.getIndex(), descriptor, monitor);
@@ -125,6 +129,14 @@
return rawReadType(descriptor, true);
}
+ public static ClassFileReader rawReadType(BinaryTypeDescriptor descriptor, boolean fullyInitialize) throws JavaModelException, ClassFormatException {
+ try {
+ return rawReadTypeTestForExists(descriptor, fullyInitialize, true);
+ } catch (FileNotFoundException e) {
+ throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
+ }
+ }
+
/**
* Read the class file from disk, circumventing the index's cache. This should only be used by callers
* that need to read information from the class file which aren't present in the index (such as method bodies).
@@ -132,15 +144,18 @@
* @return the newly-created ClassFileReader or null if the given class file does not exist.
* @throws ClassFormatException if the class file existed but was corrupt
* @throws JavaModelException if unable to read the class file due to a transient failure
+ * @throws FileNotFoundException if the file does not exist
*/
- public static ClassFileReader rawReadType(BinaryTypeDescriptor descriptor, boolean fullyInitialize) throws JavaModelException, ClassFormatException {
+ public static ClassFileReader rawReadTypeTestForExists(BinaryTypeDescriptor descriptor, boolean fullyInitialize,
+ boolean useInvalidArchiveCache) throws JavaModelException, ClassFormatException, FileNotFoundException {
if (descriptor == null) {
return null;
}
if (descriptor.isInJarFile()) {
ZipFile zip = null;
try {
- zip = JavaModelManager.getJavaModelManager().getZipFile(new Path(new String(descriptor.workspacePath)));
+ zip = JavaModelManager.getJavaModelManager().getZipFile(new Path(new String(descriptor.workspacePath)),
+ useInvalidArchiveCache);
char[] entryNameCharArray = CharArrayUtils.concat(
JavaNames.fieldDescriptorToBinaryName(descriptor.fieldDescriptor), SuffixConstants.SUFFIX_class);
String entryName = new String(entryNameCharArray);
@@ -161,7 +176,18 @@
}
} else {
IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(new String(descriptor.workspacePath)));
- byte[] contents = Util.getResourceContentsAsByteArray(file);
+ byte[] contents;
+ try (InputStream stream = file.getContents(true)) {
+ contents = org.eclipse.jdt.internal.compiler.util.Util.getInputStreamAsByteArray(stream, -1);
+ } catch (CoreException e) {
+ IStatus status = e.getStatus();
+ if (status.getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
+ throw new FileNotFoundException();
+ }
+ throw new JavaModelException(e);
+ } catch (IOException e) {
+ throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
+ }
return new ClassFileReader(contents, file.getFullPath().toString().toCharArray(), fullyInitialize);
}
return null;
@@ -217,8 +243,8 @@
throw new JavaModelException(e);
}
} catch (IndexException e) {
- // Index corrupted. Rebuild it.
- index.rebuildIndex();
+ Package.log("Index corruption detected. Rebuilding index.", e); //$NON-NLS-1$
+ Indexer.getInstance().requestRebuildIndex();
}
}
}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/model/Package.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/model/Package.java
new file mode 100644
index 0000000..1aad354
--- /dev/null
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/nd/java/model/Package.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2015, 2016 Google, Inc 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Stefan Xenos (Google) - Initial implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.core.nd.java.model;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jdt.core.JavaCore;
+
+/* package */ class Package {
+ public static String PLUGIN_ID = JavaCore.PLUGIN_ID;
+
+ public static void log(Throwable e) {
+ String msg = e.getMessage();
+ if (msg == null) {
+ log("Error", e); //$NON-NLS-1$
+ } else {
+ log("Error: " + msg, e); //$NON-NLS-1$
+ }
+ }
+
+ public static void log(String message, Throwable e) {
+ log(createStatus(message, e));
+ }
+
+ public static IStatus createStatus(String msg, Throwable e) {
+ return new Status(IStatus.ERROR, PLUGIN_ID, msg, e);
+ }
+
+ public static IStatus createStatus(String msg) {
+ return new Status(IStatus.ERROR, PLUGIN_ID, msg);
+ }
+
+ public static void logInfo(String message) {
+ log(new Status(IStatus.INFO, PLUGIN_ID, message));
+ }
+
+ public static void log(IStatus status) {
+ JavaCore.getPlugin().getLog().log(status);
+ }
+}
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/IndexManager.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/IndexManager.java
index 7ce53fa..dc72697 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/IndexManager.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/indexing/IndexManager.java
@@ -28,6 +28,7 @@
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
+import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
@@ -164,7 +165,7 @@
if (count > 0)
removeIndexesState(locations);
}
- deleteIndexFiles(knownPaths);
+ deleteIndexFiles(knownPaths, null);
}
/**
* Compute the pre-built index location for a specified URL
@@ -212,17 +213,25 @@
}
return indexLocation;
}
-public void deleteIndexFiles() {
+/**
+ * Use {@link #deleteIndexFiles(IProgressMonitor)}
+ */
+public final void deleteIndexFiles() {
+ deleteIndexFiles(null);
+}
+public void deleteIndexFiles(IProgressMonitor monitor) {
if (DEBUG)
Util.verbose("Deleting index files"); //$NON-NLS-1$
this.savedIndexNamesFile.delete(); // forget saved indexes & delete each index file
- deleteIndexFiles(null);
+ deleteIndexFiles(null, monitor);
}
-private void deleteIndexFiles(SimpleSet pathsToKeep) {
+private void deleteIndexFiles(SimpleSet pathsToKeep, IProgressMonitor monitor) {
File[] indexesFiles = getSavedIndexesDirectory().listFiles();
if (indexesFiles == null) return;
+ SubMonitor subMonitor = SubMonitor.convert(monitor, indexesFiles.length);
for (int i = 0, l = indexesFiles.length; i < l; i++) {
+ subMonitor.split(1);
String fileName = indexesFiles[i].getAbsolutePath();
if (pathsToKeep != null && pathsToKeep.includes(new FileIndexLocation(indexesFiles[i]))) continue;
String suffix = ".index"; //$NON-NLS-1$
@@ -865,14 +874,16 @@
/**
* Flush current state
*/
-public synchronized void reset() {
+public void reset() {
super.reset();
- if (this.indexes != null) {
- this.indexes = new SimpleLookupTable();
- this.indexStates = null;
+ synchronized (this) {
+ if (this.indexes != null) {
+ this.indexes = new SimpleLookupTable();
+ this.indexStates = null;
+ }
+ this.indexLocations = new SimpleLookupTable();
+ this.javaPluginLocation = null;
}
- this.indexLocations = new SimpleLookupTable();
- this.javaPluginLocation = null;
}
/**
* Resets the index for a given path.
diff --git a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/processing/JobManager.java b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/processing/JobManager.java
index 71bc061..7c07d0f 100644
--- a/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/processing/JobManager.java
+++ b/org.eclipse.jdt.core/search/org/eclipse/jdt/internal/core/search/processing/JobManager.java
@@ -297,22 +297,29 @@
/**
* Flush current state
*/
- public synchronized void reset() {
+ public void reset() {
if (VERBOSE)
Util.verbose("Reset"); //$NON-NLS-1$
- if (this.processingThread != null) {
+ Thread thread;
+ synchronized (this) {
+ thread = this.processingThread;
+ }
+
+ if (thread != null) {
discardJobs(null); // discard all jobs
} else {
- /* initiate background processing */
- this.processingThread = new Thread(this, processName());
- this.processingThread.setDaemon(true);
- // less prioritary by default, priority is raised if clients are actively waiting on it
- this.processingThread.setPriority(Thread.NORM_PRIORITY-1);
- // https://bugs.eclipse.org/bugs/show_bug.cgi?id=296343
- // set the context loader to avoid leaking the current context loader
- this.processingThread.setContextClassLoader(this.getClass().getClassLoader());
- this.processingThread.start();
+ synchronized (this) {
+ /* initiate background processing */
+ this.processingThread = new Thread(this, processName());
+ this.processingThread.setDaemon(true);
+ // less prioritary by default, priority is raised if clients are actively waiting on it
+ this.processingThread.setPriority(Thread.NORM_PRIORITY-1);
+ // https://bugs.eclipse.org/bugs/show_bug.cgi?id=296343
+ // set the context loader to avoid leaking the current context loader
+ this.processingThread.setContextClassLoader(this.getClass().getClassLoader());
+ this.processingThread.start();
+ }
}
}
/**
