1) Moved net.sourceforge.phpeclipse.ui\src\net\sourceforge\phpdt back to net.sourcefo...
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / ast / AssertStatement.java
index 87f61e8..64705dc 100644 (file)
@@ -21,18 +21,17 @@ import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding;
 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
 
 public class AssertStatement extends Statement {
-       
+
        public Expression assertExpression, exceptionArgument;
 
        // for local variable attribute
        int preAssertInitStateIndex = -1;
+
        private FieldBinding assertionSyntheticFieldBinding;
-       
-       public AssertStatement(
-               Expression exceptionArgument,
-               Expression assertExpression,
-               int startPosition) {
-                       
+
+       public AssertStatement(Expression exceptionArgument,
+                       Expression assertExpression, int startPosition) {
+
                this.assertExpression = assertExpression;
                this.exceptionArgument = exceptionArgument;
                sourceStart = startPosition;
@@ -46,77 +45,85 @@ public class AssertStatement extends Statement {
                sourceEnd = assertExpression.sourceEnd;
        }
 
-       public FlowInfo analyseCode(
-               BlockScope currentScope,
-               FlowContext flowContext,
-               FlowInfo flowInfo) {
-                       
-               preAssertInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);
+       public FlowInfo analyseCode(BlockScope currentScope,
+                       FlowContext flowContext, FlowInfo flowInfo) {
 
-               Constant cst = this.assertExpression.optimizedBooleanConstant();                
-               boolean isOptimizedTrueAssertion = cst != NotAConstant && cst.booleanValue() == true;
-               boolean isOptimizedFalseAssertion = cst != NotAConstant && cst.booleanValue() == false;
+               preAssertInitStateIndex = currentScope.methodScope()
+                               .recordInitializationStates(flowInfo);
+
+               Constant cst = this.assertExpression.optimizedBooleanConstant();
+               boolean isOptimizedTrueAssertion = cst != NotAConstant
+                               && cst.booleanValue() == true;
+               boolean isOptimizedFalseAssertion = cst != NotAConstant
+                               && cst.booleanValue() == false;
 
                FlowInfo assertInfo = flowInfo.copy();
                if (isOptimizedTrueAssertion) {
                        assertInfo.setReachMode(FlowInfo.UNREACHABLE);
                }
-               assertInfo = assertExpression.analyseCode(currentScope, flowContext, assertInfo).unconditionalInits();
-               
+               assertInfo = assertExpression.analyseCode(currentScope, flowContext,
+                               assertInfo).unconditionalInits();
+
                if (exceptionArgument != null) {
-                       // only gets evaluated when escaping - results are not taken into account
-                       FlowInfo exceptionInfo = exceptionArgument.analyseCode(currentScope, flowContext, assertInfo.copy()); 
-                       
-                       if (!isOptimizedTrueAssertion){
-                               flowContext.checkExceptionHandlers(
-                                       currentScope.getJavaLangAssertionError(),
-                                       this,
-                                       exceptionInfo,
-                                       currentScope);
+                       // only gets evaluated when escaping - results are not taken into
+                       // account
+                       FlowInfo exceptionInfo = exceptionArgument.analyseCode(
+                                       currentScope, flowContext, assertInfo.copy());
+
+                       if (!isOptimizedTrueAssertion) {
+                               flowContext.checkExceptionHandlers(currentScope
+                                               .getJavaLangAssertionError(), this, exceptionInfo,
+                                               currentScope);
                        }
                }
-               
+
                // add the assert support in the clinit
                manageSyntheticAccessIfNecessary(currentScope);
                if (isOptimizedFalseAssertion) {
-                       return flowInfo; // if assertions are enabled, the following code will be unreachable
+                       return flowInfo; // if assertions are enabled, the following code
+                                                               // will be unreachable
                } else {
-                       return flowInfo.mergedWith(assertInfo.unconditionalInits()); 
+                       return flowInfo.mergedWith(assertInfo.unconditionalInits());
                }
        }
 
-//     public void generateCode(BlockScope currentScope, CodeStream codeStream) {
-//
-//             if ((bits & IsReachableMASK) == 0) {
-//                     return;
-//             }
-//             int pc = codeStream.position;
-//     
-//             if (this.assertionSyntheticFieldBinding != null) {
-//                     Label assertionActivationLabel = new Label(codeStream);
-//                     codeStream.getstatic(this.assertionSyntheticFieldBinding);
-//                     codeStream.ifne(assertionActivationLabel);
-//                     Label falseLabel = new Label(codeStream);
-//                     assertExpression.generateOptimizedBoolean(currentScope, codeStream, (falseLabel = new Label(codeStream)), null , true);
-//                     codeStream.newJavaLangAssertionError();
-//                     codeStream.dup();
-//                     if (exceptionArgument != null) {
-//                             exceptionArgument.generateCode(currentScope, codeStream, true);
-//                             codeStream.invokeJavaLangAssertionErrorConstructor(exceptionArgument.implicitConversion & 0xF);
-//                     } else {
-//                             codeStream.invokeJavaLangAssertionErrorDefaultConstructor();
-//                     }
-//                     codeStream.athrow();
-//                     falseLabel.place();
-//                     assertionActivationLabel.place();
-//             }
-//             
-//             // May loose some local variable initializations : affecting the local variable attributes
-//             if (preAssertInitStateIndex != -1) {
-//                     codeStream.removeNotDefinitelyAssignedVariables(currentScope, preAssertInitStateIndex);
-//             }       
-//             codeStream.recordPositionsFrom(pc, this.sourceStart);
-//     }
+       // public void generateCode(BlockScope currentScope, CodeStream codeStream)
+       // {
+       //
+       // if ((bits & IsReachableMASK) == 0) {
+       // return;
+       // }
+       // int pc = codeStream.position;
+       //      
+       // if (this.assertionSyntheticFieldBinding != null) {
+       // Label assertionActivationLabel = new Label(codeStream);
+       // codeStream.getstatic(this.assertionSyntheticFieldBinding);
+       // codeStream.ifne(assertionActivationLabel);
+       // Label falseLabel = new Label(codeStream);
+       // assertExpression.generateOptimizedBoolean(currentScope, codeStream,
+       // (falseLabel = new Label(codeStream)), null , true);
+       // codeStream.newJavaLangAssertionError();
+       // codeStream.dup();
+       // if (exceptionArgument != null) {
+       // exceptionArgument.generateCode(currentScope, codeStream, true);
+       // codeStream.invokeJavaLangAssertionErrorConstructor(exceptionArgument.implicitConversion
+       // & 0xF);
+       // } else {
+       // codeStream.invokeJavaLangAssertionErrorDefaultConstructor();
+       // }
+       // codeStream.athrow();
+       // falseLabel.place();
+       // assertionActivationLabel.place();
+       // }
+       //              
+       // // May loose some local variable initializations : affecting the local
+       // variable attributes
+       // if (preAssertInitStateIndex != -1) {
+       // codeStream.removeNotDefinitelyAssignedVariables(currentScope,
+       // preAssertInitStateIndex);
+       // }
+       // codeStream.recordPositionsFrom(pc, this.sourceStart);
+       // }
        public StringBuffer printStatement(int tab, StringBuffer output) {
 
                printIndent(tab, output);
@@ -128,20 +135,24 @@ public class AssertStatement extends Statement {
                }
                return output.append(';');
        }
+
        public void resolve(BlockScope scope) {
 
                assertExpression.resolveTypeExpecting(scope, BooleanBinding);
                if (exceptionArgument != null) {
-                       TypeBinding exceptionArgumentType = exceptionArgument.resolveType(scope);
-                       if (exceptionArgumentType != null){
-                               if (exceptionArgumentType.id == T_void){
-                                       scope.problemReporter().illegalVoidExpression(exceptionArgument);
+                       TypeBinding exceptionArgumentType = exceptionArgument
+                                       .resolveType(scope);
+                       if (exceptionArgumentType != null) {
+                               if (exceptionArgumentType.id == T_void) {
+                                       scope.problemReporter().illegalVoidExpression(
+                                                       exceptionArgument);
                                }
-                               exceptionArgument.implicitConversion = (exceptionArgumentType.id << 4) + exceptionArgumentType.id;
+                               exceptionArgument.implicitConversion = (exceptionArgumentType.id << 4)
+                                               + exceptionArgumentType.id;
                        }
                }
        }
-       
+
        public void traverse(ASTVisitor visitor, BlockScope scope) {
 
                if (visitor.visit(this, scope)) {
@@ -151,20 +162,23 @@ public class AssertStatement extends Statement {
                        }
                }
                visitor.endVisit(this, scope);
-       }       
-       
+       }
+
        public void manageSyntheticAccessIfNecessary(BlockScope currentScope) {
 
                // need assertion flag: $assertionsDisabled on outer most source clas
-               // (in case of static member of interface, will use the outermost static member - bug 22334)
+               // (in case of static member of interface, will use the outermost static
+               // member - bug 22334)
                SourceTypeBinding outerMostClass = currentScope.enclosingSourceType();
-               while (outerMostClass.isLocalType()){
+               while (outerMostClass.isLocalType()) {
                        ReferenceBinding enclosing = outerMostClass.enclosingType();
-                       if (enclosing == null || enclosing.isInterface()) break;
+                       if (enclosing == null || enclosing.isInterface())
+                               break;
                        outerMostClass = (SourceTypeBinding) enclosing;
                }
 
-               this.assertionSyntheticFieldBinding = outerMostClass.addSyntheticField(this, currentScope);
+               this.assertionSyntheticFieldBinding = outerMostClass.addSyntheticField(
+                               this, currentScope);
 
                // find <clinit> and enable assertion support
                TypeDeclaration typeDeclaration = outerMostClass.scope.referenceType();
@@ -172,7 +186,8 @@ public class AssertStatement extends Statement {
                for (int i = 0, max = methods.length; i < max; i++) {
                        AbstractMethodDeclaration method = methods[i];
                        if (method.isClinit()) {
-                               ((Clinit) method).addSupportForAssertion(assertionSyntheticFieldBinding);
+                               ((Clinit) method)
+                                               .addSupportForAssertion(assertionSyntheticFieldBinding);
                                break;
                        }
                }
@@ -190,5 +205,5 @@ public class AssertStatement extends Statement {
                }
                return buffer.toString();
        }
-       
+
 }