Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*******************************************************************************
* Copyright (c) 2000, 2014 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
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Stephan Herrmann - Contributions for
* bug 335093 - [compiler][null] minimal hook for future null annotation support
* bug 349326 - [1.7] new warning for missing try-with-resources
* bug 186342 - [compiler][null] Using annotations for null checking
* bug 365983 - [compiler][null] AIOOB with null annotation analysis and varargs
* bug 368546 - [compiler][resource] Avoid remaining false positives found when compiling the Eclipse SDK
* bug 370930 - NonNull annotation not considered for enhanced for loops
* bug 365859 - [compiler][null] distinguish warnings based on flow analysis vs. null annotations
* bug 392862 - [1.8][compiler][null] Evaluate null annotations on array types
* bug 331649 - [compiler][null] consider null annotations for fields
* bug 383368 - [compiler][null] syntactic null analysis for field references
* Bug 392099 - [1.8][compiler][null] Apply null annotation on types for null analysis
* Bug 415043 - [1.8][null] Follow-up re null type annotations after bug 392099
* Bug 415291 - [1.8][null] differentiate type incompatibilities due to null annotations
* Bug 392238 - [1.8][compiler][null] Detect semantically invalid null type annotations
* Bug 416307 - [1.8][compiler][null] subclass with type parameter substitution confuses null checking
* Bug 417758 - [1.8][null] Null safety compromise during array creation.
* Bug 400874 - [1.8][compiler] Inference infrastructure should evolve to meet JLS8 18.x (Part G of JSR335 spec)
* Bug 424415 - [1.8][compiler] Eventual resolution of ReferenceExpression is not seen to be happening.
* Bug 418537 - [1.8][null] Fix null type annotation analysis for poly conditional expressions
* Bug 428352 - [1.8][compiler] Resolution errors don't always surface
* Bug 429430 - [1.8] Lambdas and method reference infer wrong exception type with generics (RuntimeException instead of IOException)
* Andy Clement - Contributions for
* Bug 383624 - [1.8][compiler] Revive code generation support for type annotations (from Olivier's work)
* Bug 409250 - [1.8][compiler] Various loose ends in 308 code generation
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.*;
public abstract class Statement extends ASTNode {
/**
* Answers true if the if is identified as a known coding pattern which
* should be tolerated by dead code analysis.
* e.g. if (DEBUG) print(); // no complaint
* Only invoked when overall condition is known to be optimizeable into false/true.
*/
protected static boolean isKnowDeadCodePattern(Expression expression) {
// if (!DEBUG) print(); - tolerated
if (expression instanceof UnaryExpression) {
expression = ((UnaryExpression) expression).expression;
}
// if (DEBUG) print(); - tolerated
if (expression instanceof Reference) return true;
// if (expression instanceof BinaryExpression) {
// BinaryExpression binary = (BinaryExpression) expression;
// switch ((binary.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT/* operator */) {
// case OperatorIds.AND_AND :
// case OperatorIds.OR_OR :
// break;
// default:
// // if (DEBUG_LEVEL > 0) print(); - tolerated
// if ((binary.left instanceof Reference) && binary.right.constant != Constant.NotAConstant)
// return true;
// // if (0 < DEBUG_LEVEL) print(); - tolerated
// if ((binary.right instanceof Reference) && binary.left.constant != Constant.NotAConstant)
// return true;
// }
// }
return false;
}
public abstract FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo);
public static final int NOT_COMPLAINED = 0;
public static final int COMPLAINED_FAKE_REACHABLE = 1;
public static final int COMPLAINED_UNREACHABLE = 2;
/** Analysing arguments of MessageSend, ExplicitConstructorCall, AllocationExpression. */
protected void analyseArguments(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, MethodBinding methodBinding, Expression[] arguments)
{
// compare actual null-status against parameter annotations of the called method:
if (arguments != null) {
CompilerOptions compilerOptions = currentScope.compilerOptions();
if (compilerOptions.sourceLevel >= ClassFileConstants.JDK1_7 && methodBinding.isPolymorphic())
return;
boolean considerTypeAnnotations = compilerOptions.sourceLevel >= ClassFileConstants.JDK1_8
&& compilerOptions.isAnnotationBasedNullAnalysisEnabled;
boolean hasJDK15NullAnnotations = methodBinding.parameterNonNullness != null;
int numParamsToCheck = methodBinding.parameters.length;
int varArgPos = -1;
TypeBinding varArgsType = null;
boolean passThrough = false;
if (considerTypeAnnotations || hasJDK15NullAnnotations) {
// check if varargs need special treatment:
if (methodBinding.isVarargs()) {
varArgPos = numParamsToCheck-1;
// this if-block essentially copied from generateArguments(..):
if (numParamsToCheck == arguments.length) {
varArgsType = methodBinding.parameters[varArgPos];
TypeBinding lastType = arguments[varArgPos].resolvedType;
if (lastType == TypeBinding.NULL
|| (varArgsType.dimensions() == lastType.dimensions()
&& lastType.isCompatibleWith(varArgsType)))
passThrough = true; // pass directly as-is
}
if (!passThrough)
numParamsToCheck--; // with non-passthrough varargs last param is fed from individual args -> don't check
}
}
if (considerTypeAnnotations) {
for (int i=0; i paramLength) {
// right number but not directly compatible or too many arguments - wrap extra into array
// called with (argLength - lastIndex) elements : foo(1, 2) or foo(1, 2, 3, 4)
// need to gen elements into an array, then gen each remaining element into created array
codeStream.generateInlinedValue(argLength - varArgIndex);
codeStream.newArray(codeGenVarArgsType); // create a mono-dimensional array
for (int i = varArgIndex; i < argLength; i++) {
codeStream.dup();
codeStream.generateInlinedValue(i - varArgIndex);
arguments[i].generateCode(currentScope, codeStream, true);
codeStream.arrayAtPut(elementsTypeID, false);
}
} else if (argLength == paramLength) {
// right number of arguments - could be inexact - pass argument as is
TypeBinding lastType = arguments[varArgIndex].resolvedType;
if (lastType == TypeBinding.NULL
|| (varArgsType.dimensions() == lastType.dimensions()
&& lastType.isCompatibleWith(varArgsType))) {
// foo(1, new int[]{2, 3}) or foo(1, null) --> last arg is passed as-is
arguments[varArgIndex].generateCode(currentScope, codeStream, true);
} else {
// right number but not directly compatible or too many arguments - wrap extra into array
// need to gen elements into an array, then gen each remaining element into created array
codeStream.generateInlinedValue(1);
codeStream.newArray(codeGenVarArgsType); // create a mono-dimensional array
codeStream.dup();
codeStream.generateInlinedValue(0);
arguments[varArgIndex].generateCode(currentScope, codeStream, true);
codeStream.arrayAtPut(elementsTypeID, false);
}
} else { // not enough arguments - pass extra empty array
// scenario: foo(1) --> foo(1, new int[0])
// generate code for an empty array of parameterType
codeStream.generateInlinedValue(0);
codeStream.newArray(codeGenVarArgsType); // create a mono-dimensional array
}
} else if (arguments != null) { // standard generation for method arguments
for (int i = 0, max = arguments.length; i < max; i++)
arguments[i].generateCode(currentScope, codeStream, true);
}
}
public abstract void generateCode(BlockScope currentScope, CodeStream codeStream);
public boolean isBoxingCompatible(TypeBinding expressionType, TypeBinding targetType, Expression expression, Scope scope) {
if (scope.isBoxingCompatibleWith(expressionType, targetType))
return true;
return expressionType.isBaseType() // narrowing then boxing ? Only allowed for some target types see 362279
&& !targetType.isBaseType()
&& !targetType.isTypeVariable()
&& scope.compilerOptions().sourceLevel >= org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants.JDK1_5 // autoboxing
&& (targetType.id == TypeIds.T_JavaLangByte || targetType.id == TypeIds.T_JavaLangShort || targetType.id == TypeIds.T_JavaLangCharacter)
&& expression.isConstantValueOfTypeAssignableToType(expressionType, scope.environment().computeBoxingType(targetType));
}
public boolean isEmptyBlock() {
return false;
}
public boolean isValidJavaStatement() {
//the use of this method should be avoid in most cases
//and is here mostly for documentation purpose.....
//while the parser is responsible for creating
//welled formed expression statement, which results
//in the fact that java-non-semantic-expression-used-as-statement
//should not be parsed...thus not being built.
//It sounds like the java grammar as help the compiler job in removing
//-by construction- some statement that would have no effect....
//(for example all expression that may do side-effects are valid statement
// -this is an approximative idea.....-)
return true;
}
public StringBuffer print(int indent, StringBuffer output) {
return printStatement(indent, output);
}
public abstract StringBuffer printStatement(int indent, StringBuffer output);
public abstract void resolve(BlockScope scope);
/**
* Returns case constant associated to this statement (NotAConstant if none)
*/
public Constant resolveCase(BlockScope scope, TypeBinding testType, SwitchStatement switchStatement) {
// statement within a switch that are not case are treated as normal statement....
resolve(scope);
return Constant.NotAConstant;
}
/**
* Implementation of {@link org.eclipse.jdt.internal.compiler.lookup.InvocationSite#invocationTargetType}
* suitable at this level. Subclasses should override as necessary.
* @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#invocationTargetType()
*/
public TypeBinding invocationTargetType() {
return null;
}
/** Simpler notion of expected type, suitable for code assist purposes. */
public TypeBinding expectedType() {
// for all but FunctionalExpressions, this is the same as invocationTargetType.
return invocationTargetType();
}
public ExpressionContext getExpressionContext() {
return ExpressionContext.VANILLA_CONTEXT;
}
/**
* For all constructor invocations: find the constructor binding;
* if site.innersNeedUpdate() perform some post processing for those and produce
* any updates as side-effects into 'argumentTypes'.
*/
protected MethodBinding findConstructorBinding(BlockScope scope, Invocation site, ReferenceBinding receiverType, TypeBinding[] argumentTypes) {
MethodBinding ctorBinding = scope.getConstructor(receiverType, argumentTypes, site);
resolvePolyExpressionArguments(site, ctorBinding, argumentTypes, scope);
return ctorBinding;
}
/**
* If an exception-throwing statement is resolved within the scope of a lambda, record the exception type(s).
* It is likely wrong to do this during resolve, should probably use precise flow information.
*/
protected void recordExceptionsForEnclosingLambda(BlockScope scope, TypeBinding... thrownExceptions) {
MethodScope methodScope = scope.methodScope();
if (methodScope != null && methodScope.referenceContext instanceof LambdaExpression) {
LambdaExpression lambda = (LambdaExpression) methodScope.referenceContext;
for (int i = 0; i < thrownExceptions.length; i++)
lambda.throwsException(thrownExceptions[i]);
}
}
}
