src/org/eclipse/jdt/internal/compiler/flow/ConditionalFlowInfo.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package org.eclipse.jdt.internal.compiler.flow;
  12
  13 import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
  14 import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
  15
  16 /**
  17  * Record conditional initialization status during definite assignment analysis
  18  *
  19  */
  20 public class ConditionalFlowInfo extends FlowInfo {
  21
  22         public FlowInfo initsWhenTrue;
  23         public FlowInfo initsWhenFalse;
  24
  25         ConditionalFlowInfo(FlowInfo initsWhenTrue, FlowInfo initsWhenFalse){
  26
  27                 this.initsWhenTrue = initsWhenTrue;
  28                 this.initsWhenFalse = initsWhenFalse;
  29         }
  30
  31         public FlowInfo addInitializationsFrom(FlowInfo otherInits) {
  32
  33                 this.initsWhenTrue.addInitializationsFrom(otherInits);
  34                 this.initsWhenFalse.addInitializationsFrom(otherInits);
  35                 return this;
  36         }
  37
  38         public FlowInfo addPotentialInitializationsFrom(FlowInfo otherInits) {
  39
  40                 this.initsWhenTrue.addPotentialInitializationsFrom(otherInits);
  41                 this.initsWhenFalse.addPotentialInitializationsFrom(otherInits);
  42                 return this;
  43         }
  44
  45         public FlowInfo asNegatedCondition() {
  46
  47                 FlowInfo extra = initsWhenTrue;
  48                 initsWhenTrue = initsWhenFalse;
  49                 initsWhenFalse = extra;
  50                 return this;
  51         }
  52
  53         public FlowInfo copy() {
  54
  55                 return new ConditionalFlowInfo(initsWhenTrue.copy(), initsWhenFalse.copy());
  56         }
  57
  58         public FlowInfo initsWhenFalse() {
  59
  60                 return initsWhenFalse;
  61         }
  62
  63         public FlowInfo initsWhenTrue() {
  64
  65                 return initsWhenTrue;
  66         }
  67
  68         /**
  69          * Check status of definite assignment for a field.
  70          */
  71         public boolean isDefinitelyAssigned(FieldBinding field) {
  72
  73                 return initsWhenTrue.isDefinitelyAssigned(field)
  74                                 && initsWhenFalse.isDefinitelyAssigned(field);
  75         }
  76
  77         /**
  78          * Check status of definite assignment for a local variable.
  79          */
  80         public boolean isDefinitelyAssigned(LocalVariableBinding local) {
  81
  82                 return initsWhenTrue.isDefinitelyAssigned(local)
  83                                 && initsWhenFalse.isDefinitelyAssigned(local);
  84         }
  85
  86         /**
  87          * Check status of definite non-null assignment for a field.
  88          */
  89         public boolean isDefinitelyNonNull(FieldBinding field) {
  90
  91                 return initsWhenTrue.isDefinitelyNonNull(field)
  92                                 && initsWhenFalse.isDefinitelyNonNull(field);
  93         }
  94
  95         /**
  96          * Check status of definite non-null assignment for a local variable.
  97          */
  98         public boolean isDefinitelyNonNull(LocalVariableBinding local) {
  99
 100                 return initsWhenTrue.isDefinitelyNonNull(local)
 101                                 && initsWhenFalse.isDefinitelyNonNull(local);
 102         }
 103
 104         /**
 105          * Check status of definite null assignment for a field.
 106          */
 107         public boolean isDefinitelyNull(FieldBinding field) {
 108
 109                 return initsWhenTrue.isDefinitelyNull(field)
 110                                 && initsWhenFalse.isDefinitelyNull(field);
 111         }
 112
 113         /**
 114          * Check status of definite null assignment for a local variable.
 115          */
 116         public boolean isDefinitelyNull(LocalVariableBinding local) {
 117
 118                 return initsWhenTrue.isDefinitelyNull(local)
 119                                 && initsWhenFalse.isDefinitelyNull(local);
 120         }
 121
 122         public int reachMode(){
 123                 return unconditionalInits().reachMode();
 124         }
 125
 126         public boolean isReachable(){
 127
 128                 return unconditionalInits().isReachable();
 129                 //should maybe directly be: false
 130         }
 131
 132         /**
 133          * Check status of potential assignment for a field.
 134          */
 135         public boolean isPotentiallyAssigned(FieldBinding field) {
 136
 137                 return initsWhenTrue.isPotentiallyAssigned(field)
 138                                 || initsWhenFalse.isPotentiallyAssigned(field);
 139         }
 140
 141         /**
 142          * Check status of potential assignment for a local variable.
 143          */
 144         public boolean isPotentiallyAssigned(LocalVariableBinding local) {
 145
 146                 return initsWhenTrue.isPotentiallyAssigned(local)
 147                                 || initsWhenFalse.isPotentiallyAssigned(local);
 148         }
 149
 150         /**
 151          * Record a field got definitely assigned.
 152          */
 153         public void markAsDefinitelyAssigned(FieldBinding field) {
 154
 155                 initsWhenTrue.markAsDefinitelyAssigned(field);
 156                 initsWhenFalse.markAsDefinitelyAssigned(field);
 157         }
 158
 159         /**
 160          * Record a field got definitely assigned.
 161          */
 162         public void markAsDefinitelyAssigned(LocalVariableBinding local) {
 163
 164                 initsWhenTrue.markAsDefinitelyAssigned(local);
 165                 initsWhenFalse.markAsDefinitelyAssigned(local);
 166         }
 167
 168         /**
 169          * Record a field got definitely assigned to non-null value.
 170          */
 171         public void markAsDefinitelyNonNull(FieldBinding field) {
 172
 173                 initsWhenTrue.markAsDefinitelyNonNull(field);
 174                 initsWhenFalse.markAsDefinitelyNonNull(field);
 175         }
 176
 177         /**
 178          * Record a field got definitely assigned to non-null value
 179          */
 180         public void markAsDefinitelyNonNull(LocalVariableBinding local) {
 181
 182                 initsWhenTrue.markAsDefinitelyNonNull(local);
 183                 initsWhenFalse.markAsDefinitelyNonNull(local);
 184         }
 185
 186         /**
 187          * Record a field got definitely assigned to null.
 188          */
 189         public void markAsDefinitelyNull(FieldBinding field) {
 190
 191                 initsWhenTrue.markAsDefinitelyNull(field);
 192                 initsWhenFalse.markAsDefinitelyNull(field);
 193         }
 194
 195         /**
 196          * Record a field got definitely assigned to null.
 197          */
 198         public void markAsDefinitelyNull(LocalVariableBinding local) {
 199
 200                 initsWhenTrue.markAsDefinitelyNull(local);
 201                 initsWhenFalse.markAsDefinitelyNull(local);
 202         }
 203
 204         /**
 205          * Clear the initialization info for a field
 206          */
 207         public void markAsDefinitelyNotAssigned(FieldBinding field) {
 208
 209                 initsWhenTrue.markAsDefinitelyNotAssigned(field);
 210                 initsWhenFalse.markAsDefinitelyNotAssigned(field);
 211         }
 212
 213         /**
 214          * Clear the initialization info for a local variable
 215          */
 216         public void markAsDefinitelyNotAssigned(LocalVariableBinding local) {
 217
 218                 initsWhenTrue.markAsDefinitelyNotAssigned(local);
 219                 initsWhenFalse.markAsDefinitelyNotAssigned(local);
 220         }
 221
 222         public FlowInfo setReachMode(int reachMode) {
 223
 224                 initsWhenTrue.setReachMode(reachMode);
 225                 initsWhenFalse.setReachMode(reachMode);
 226                 return this;
 227         }
 228
 229         /**
 230          * Converts conditional receiver into inconditional one, updated in the following way: <ul>
 231          * <li> intersection of definitely assigned variables,
 232          * <li> union of potentially assigned variables.
 233          * </ul>
 234          */
 235         public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits) {
 236
 237                 return unconditionalInits().mergedWith(otherInits);
 238         }
 239
 240         public String toString() {
 241
 242                 return "FlowInfo<true: " + initsWhenTrue.toString() + ", false: " + initsWhenFalse.toString() + ">"; //$NON-NLS-1$ //$NON-NLS-3$ //$NON-NLS-2$
 243         }
 244
 245         public UnconditionalFlowInfo unconditionalInits() {
 246
 247                 return initsWhenTrue.unconditionalInits().copy()
 248                                 .mergedWith(initsWhenFalse.unconditionalInits());
 249         }
 250 }