Attachment #36841 for bug #132677

View | Details | Raw Unified | Return to bug 132677
Collapse All | Expand All




		arguments,
		arguments,
		ProblemSeverities.Error | ProblemSeverities.Abort | ProblemSeverities.Fatal,
		nameSourceStart(location),
		nameSourceEnd(location));
}
public void abstractMethodCannotBeOverridden(SourceTypeBinding type, MethodBinding concreteMethod) {


		IProblem.DirectInvocationOfAbstractMethod,
		new String[] {new String(method.declaringClass.readableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, false)},
		new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true)},
		nameSourceStart(messageSend),
		nameSourceEnd(messageSend));
}
public void cannotExtendEnum(SourceTypeBinding type, TypeReference superclass, TypeBinding superTypeBinding) {
	String name = new String(type.sourceName());

			new String[] {new String(method.declaringClass.readableName()), typesAsString(method.isVarargs(), method.parameters, false)},
			new String[] {new String(method.declaringClass.shortReadableName()), typesAsString(method.isVarargs(), method.parameters, true)},
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));
	} else {
		this.handle(
			IProblem.UsingDeprecatedMethod,
			new String[] {new String(method.declaringClass.readableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, false)},
			new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true)},
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));
	}
}
private int nameSourceStart(ASTNode node) {
	if (node instanceof MessageSend) {
		MessageSend messageSend = (MessageSend) node;
		return (int) (messageSend.nameSourcePosition >>> 32);
	}
	if (node instanceof AllocationExpression) {
		AllocationExpression allocationExpression = (AllocationExpression) node;
		if (allocationExpression instanceof JavadocAllocationExpression) {
			JavadocAllocationExpression javadocAllocationExpression = (JavadocAllocationExpression) allocationExpression;
			return javadocAllocationExpression.sourceStart;			
		}
		if (allocationExpression.enumConstant != null) {
			return allocationExpression.enumConstant.sourceStart;
		}
		return allocationExpression.type.sourceStart;
	}
	return node.sourceStart;
}
private int nameSourceEnd(ASTNode node) {
	if (node instanceof MessageSend) {
		MessageSend messageSend = (MessageSend) node;
		return (int) messageSend.nameSourcePosition;
	}
	if (node instanceof AllocationExpression) {
		AllocationExpression allocationExpression = (AllocationExpression) node;
		if (allocationExpression instanceof JavadocAllocationExpression) {
			JavadocAllocationExpression javadocAllocationExpression = (JavadocAllocationExpression) allocationExpression;
			return javadocAllocationExpression.originalSourceEnd;			
		}
		if (allocationExpression.enumConstant != null) {
			return allocationExpression.enumConstant.sourceEnd;
		}
		return allocationExpression.type.sourceEnd;
	}
	return node.sourceEnd;
}
private int invocationSiteSourceStart(InvocationSite invocationSite) {
	if (invocationSite instanceof ASTNode) {
		return nameSourceStart((ASTNode) invocationSite);
	}
	return invocationSite.sourceStart();
}
private int invocationSiteSourceEnd(InvocationSite invocationSite) {
	if (invocationSite instanceof ASTNode) {
		return nameSourceEnd((ASTNode) invocationSite);
	}
	return invocationSite.sourceEnd();
}
public void deprecatedType(TypeBinding type, ASTNode location) {
	if (location == null) return; // 1G828DN - no type ref for synthetic arguments
	int severity = computeSeverity(IProblem.UsingDeprecatedType);

		id,
		new String[] {new String(recType.readableName()), new String(messageSend.selector), buffer.toString()},
		new String[] {new String(recType.shortReadableName()), new String(messageSend.selector), shortBuffer.toString()},
		nameSourceStart(messageSend),
		nameSourceEnd(messageSend));
}
public void errorThisSuperInStatic(ASTNode reference) {
	String[] arguments = new String[] {reference.isSuper() ? "super" : "this"}; //$NON-NLS-2$ //$NON-NLS-1$

			new String[] { 
				MessageFormat.format(messageTemplate,
						new String[]{new String(method.shortReadableName())})},
			nameSourceStart(location),
			nameSourceEnd(location));
	else
		this.handle(
			problemId,

					new String[]{
						new String(method.shortReadableName()),
				        new String(method.declaringClass.shortReadableName())})},
			nameSourceStart(location),
			nameSourceEnd(location));
}
public void forbiddenReference(TypeBinding type, ASTNode location, String messageTemplate, int problemId) {
	if (location == null) return;

		IProblem.InvalidVoidExpression,
		NoArgument,
		NoArgument,
		nameSourceStart(location),
		nameSourceEnd(location));
}
public void importProblem(ImportReference importRef, Binding expectedImport) {
	if (expectedImport instanceof FieldBinding) {

		new String[] {new String(method.declaringClass.readableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, false)},
		new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true)},
		severity,
		nameSourceStart(location),
		nameSourceEnd(location));
}
public void inheritedMethodReducesVisibility(SourceTypeBinding type, MethodBinding concreteMethod, MethodBinding[] abstractMethods) {
	StringBuffer concreteSignature = new StringBuffer();

		(statement instanceof ExplicitConstructorCall)
			&& (((ExplicitConstructorCall) statement).accessMode == ExplicitConstructorCall.ImplicitSuper);

	int sourceStart = nameSourceStart(statement);
	int sourceEnd = nameSourceEnd(statement);
	if (statement instanceof AllocationExpression) {
		AllocationExpression allocation = (AllocationExpression)statement;
		if (allocation.enumConstant != null) {
			sourceStart = allocation.enumConstant.sourceStart;
			sourceEnd = allocation.enumConstant.sourceEnd;
		}
	}
	
	int id = IProblem.UndefinedConstructor; //default...
    MethodBinding shownConstructor = targetConstructor;

							closestParameterTypeShortNames,
							parameterTypeShortNames
						},
						nameSourceStart(messageSend),
						nameSourceEnd(messageSend));
					return;
			}			
			break;

				        new String(inferredTypeArgument.shortReadableName()), 
				        new String(typeParameter.sourceName), 
				        parameterBoundAsString(typeParameter, true) },
				nameSourceStart(messageSend),
				nameSourceEnd(messageSend));		    
			return;
		case ProblemReasons.TypeParameterArityMismatch :
			problemMethod = (ProblemMethodBinding) method;

					        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true), 
					        new String(shownMethod.declaringClass.shortReadableName()), 
					        typesAsString(method.isVarargs(), method.parameters, true) },
					nameSourceStart(messageSend),
					nameSourceEnd(messageSend));		    
			} else {
				this.handle(
					IProblem.IncorrectArityForParameterizedMethod  ,

					        new String(shownMethod.declaringClass.shortReadableName()), 
							typesAsString(false, shownMethod.typeVariables, true),
					        typesAsString(method.isVarargs(), method.parameters, true) },
					nameSourceStart(messageSend),
					nameSourceEnd(messageSend));		    
			}
			return;
		case ProblemReasons.ParameterizedMethodTypeMismatch :

				        new String(shownMethod.declaringClass.shortReadableName()), 
						typesAsString(false, ((ParameterizedGenericMethodBinding)shownMethod).typeArguments, true),
				        typesAsString(method.isVarargs(), method.parameters, true) },
				nameSourceStart(messageSend),
				nameSourceEnd(messageSend));		    
			return;
		case ProblemReasons.TypeArgumentsForRawGenericMethod :
			problemMethod = (ProblemMethodBinding) method;

				        typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true), 
				        new String(shownMethod.declaringClass.shortReadableName()), 
				        typesAsString(method.isVarargs(), method.parameters, true) },
				nameSourceStart(messageSend),
				nameSourceEnd(messageSend));		       
			return;
		case ProblemReasons.NoError : // 0
		default :

		new String[] {
			new String(method.declaringClass.shortReadableName()),
			new String(shownMethod.selector), typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true)},
		nameSourceStart(messageSend),
		nameSourceEnd(messageSend));
}
public void invalidNullToSynchronize(Expression expression) {
	this.handle(

				new String[] {new String(method.declaringClass.readableName()), typesAsString(method.isVarargs(), method.parameters, false)},
				new String[] {new String(method.declaringClass.shortReadableName()), typesAsString(method.isVarargs(), method.parameters, true)},
				severity,
				nameSourceStart(location),
				nameSourceEnd(location));
		} else {
			this.handle(
				IProblem.JavadocUsingDeprecatedMethod,
				new String[] {new String(method.declaringClass.readableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, false)},
				new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true)},
				severity,
				nameSourceStart(location),
				nameSourceEnd(location));
		}
	}
}

			new String[] {new String(recType.readableName()), new String(messageSend.selector), buffer.toString()},
			new String[] {new String(recType.shortReadableName()), new String(messageSend.selector), shortBuffer.toString()},
			severity,
			nameSourceStart(messageSend),
			nameSourceEnd(messageSend));
	}
}
public void javadocInvalidConstructor(Statement statement, MethodBinding targetConstructor, int modifiers) {

	if (!javadocVisibility(this.options.reportInvalidJavadocTagsVisibility, modifiers)) return;
	int sourceStart = nameSourceStart(statement);
	int sourceEnd = nameSourceEnd(statement);
	if (statement instanceof AllocationExpression) {
		AllocationExpression allocation = (AllocationExpression)statement;
		if (allocation.enumConstant != null) {
			sourceStart = allocation.enumConstant.sourceStart;
			sourceEnd = allocation.enumConstant.sourceEnd;
		}
	}
	int id = IProblem.JavadocUndefinedConstructor; //default...
	ProblemMethodBinding problemConstructor = null;
	MethodBinding shownConstructor = null;

		new String[] {new String(targetConstructor.declaringClass.readableName()), typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, false)},
		new String[] {new String(targetConstructor.declaringClass.shortReadableName()), typesAsString(targetConstructor.isVarargs(), targetConstructor.parameters, true)},
		severity,
		sourceStart,
		sourceEnd);
}
/*
 * Similar implementation than invalidField(FieldReference...)

						parameterTypeShortNames
					},
					severity,
					nameSourceStart(messageSend),
					nameSourceEnd(messageSend));
				return;
			}
			break;

				        new String(typeParameter.sourceName), 
				        parameterBoundAsString(typeParameter, true) },
				severity,
				nameSourceStart(messageSend),
				nameSourceEnd(messageSend));		    
			return;
		case ProblemReasons.TypeParameterArityMismatch :
			problemMethod = (ProblemMethodBinding) method;

							typesAsString(false, shownMethod.typeVariables, true),
					        typesAsString(method.isVarargs(), method.parameters, true) },
					severity,
					nameSourceStart(messageSend),
					nameSourceEnd(messageSend));		    
			}
			return;
		case ProblemReasons.ParameterizedMethodTypeMismatch :

						typesAsString(false, ((ParameterizedGenericMethodBinding)shownMethod).typeArguments, true),
				        typesAsString(method.isVarargs(), method.parameters, true) },
				severity,
				nameSourceStart(messageSend),
				nameSourceEnd(messageSend));		    
			return;
		case ProblemReasons.TypeArgumentsForRawGenericMethod :
			severity = computeSeverity(IProblem.JavadocTypeArgumentsForRawGenericMethod);

				        new String(shownMethod.declaringClass.shortReadableName()), 
				        typesAsString(method.isVarargs(), method.parameters, true) },
				severity,
				nameSourceStart(messageSend),
				nameSourceEnd(messageSend));		       
			return;
		case ProblemReasons.NoError : // 0
		default :

			new String(method.declaringClass.shortReadableName()),
			new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true)},
		severity,
		nameSourceStart(messageSend),
		nameSourceEnd(messageSend));
}
public void javadocInvalidParamTagName(int sourceStart, int sourceEnd) {
	this.handle(IProblem.JavadocInvalidParamTagName, NoArgument, NoArgument, sourceStart, sourceEnd);

		IProblem.StaticMethodRequested,
		new String[] {new String(method.declaringClass.readableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, false)},
		new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true)},
		nameSourceStart(messageSend),
		nameSourceEnd(messageSend));
}
public void nativeMethodsCannotBeStrictfp(ReferenceBinding type, AbstractMethodDeclaration methodDecl) {
	String[] arguments = new String[] {new String(type.sourceName()), new String(methodDecl.selector)};

				typesAsString(method.isVarargs(), method.parameters, true)
			 }, 
			severity,
			nameSourceStart(location), 
			nameSourceEnd(location)); 
		return;
	}
	int severity = computeSeverity(IProblem.NeedToEmulateMethodAccess);

			typesAsString(method.isVarargs(), method.parameters, true)
		 }, 
		 severity,
		nameSourceStart(location), 
		nameSourceEnd(location)); 
}
public void noAdditionalBoundAfterTypeVariable(TypeReference boundReference) {
	this.handle(

		typeDeclaration.sourceStart,
		typeDeclaration.sourceEnd);
}
public void nonExternalizedStringLiteral(StringLiteral location) {
	this.handle(
		IProblem.NonExternalizedStringLiteral,
		NoArgument,

		IProblem.NonStaticAccessToStaticMethod,
		new String[] {new String(method.declaringClass.readableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, false)},
		new String[] {new String(method.declaringClass.shortReadableName()), new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true)},
		nameSourceStart(location),
		nameSourceEnd(location));
}
public void nonStaticContextForEnumMemberType(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};

		id,
		new String[] { new String(targetType.readableName())}, 
		new String[] { new String(targetType.shortReadableName())}, 
		nameSourceStart(location), 
		nameSourceEnd(location)); 
}
public void notCompatibleTypesError(EqualExpression expression, TypeBinding leftType, TypeBinding rightType) {
	String leftName = new String(leftType.readableName());

		IProblem.TypeMismatch,
		new String[] {new String(actualType.readableName()), new String(expectedType.readableName())},
		new String[] {new String(actualType.shortReadableName()), new String(expectedType.shortReadableName())},
		nameSourceStart(location),
		nameSourceEnd(location));
}
public void typeMismatchError(TypeBinding typeArgument, TypeVariableBinding typeParameter, ReferenceBinding genericType, ASTNode location) {
    if (location == null) { // binary case

				typesAsString(rawMethod.original().isVarargs(), rawMethod.parameters, true),
			 },
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));    
    } else {
		this.handle(
			IProblem.UnsafeRawGenericMethodInvocation,

				typesAsString(rawMethod.original().isVarargs(), rawMethod.parameters, true),
			 },
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));    
    }
}
public void unsafeRawInvocation(ASTNode location, MethodBinding rawMethod) {

				new String(rawMethod.declaringClass.erasure().shortReadableName()),
			 }, 
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));    
    } else {
		this.handle(
			IProblem.UnsafeRawMethodInvocation,

				new String(rawMethod.declaringClass.erasure().shortReadableName()),
			 },
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));    
    }
}
public void unsafeReturnTypeOverride(MethodBinding currentMethod, MethodBinding inheritedMethod, SourceTypeBinding type) {

				new String(exceptionType.shortReadableName()),
			 }, 
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));
	} else {
		this.handle(
			IProblem.UnusedMethodDeclaredThrownException,

				new String(exceptionType.shortReadableName()),
			 }, 
			severity,
			nameSourceStart(location),
			nameSourceEnd(location));
	}
}
public void unusedImport(ImportReference importRef) {

					new String(varargsType.elementsType().shortReadableName()), 
			},
			severity,
			invocationSiteSourceStart(location),
			invocationSiteSourceEnd(location));
	} else {
		this.handle(
			IProblem.MethodVarargsArgumentNeedCast,

					new String(varargsType.elementsType().shortReadableName()), 
			},
			severity,
			invocationSiteSourceStart(location),
			invocationSiteSourceEnd(location));
	}
}
public void varargsConflict(MethodBinding method1, MethodBinding method2, SourceTypeBinding type) {

				new String(offendingArgument.shortReadableName()),
				new String(offendingParameter.shortReadableName()),
			 }, 
			nameSourceStart(location),
			nameSourceEnd(location));    
    } else {
		this.handle(
			IProblem.WildcardMethodInvocation,

				new String(offendingArgument.shortReadableName()),
				new String(offendingParameter.shortReadableName()),
			 }, 
			nameSourceStart(location),
			nameSourceEnd(location));
    }
}
public void wrongSequenceOfExceptionTypesError(TryStatement statement, TypeBinding exceptionType, int under, TypeBinding hidingExceptionType) {

Return to bug 132677