Ejemplo n.º 1
0
  public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {

    // Consider the try block and catch block so as to compute the intersection of initializations
    // and
    // the minimum exit relative depth amongst all of them. Then consider the subroutine, and append
    // its
    // initialization to the try/catch ones, if the subroutine completes normally. If the subroutine
    // does not
    // complete, then only keep this result for the rest of the analysis

    // process the finally block (subroutine) - create a context for the subroutine

    preTryInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);

    if (anyExceptionVariable != null) {
      anyExceptionVariable.useFlag = LocalVariableBinding.USED;
    }
    if (returnAddressVariable != null) { // TODO (philippe) if subroutine is escaping, unused
      returnAddressVariable.useFlag = LocalVariableBinding.USED;
    }
    InsideSubRoutineFlowContext insideSubContext;
    FinallyFlowContext finallyContext;
    UnconditionalFlowInfo subInfo;
    if (subRoutineStartLabel == null) {
      // no finally block
      insideSubContext = null;
      finallyContext = null;
      subInfo = null;
    } else {
      // analyse finally block first
      insideSubContext = new InsideSubRoutineFlowContext(flowContext, this);
      subInfo =
          finallyBlock
              .analyseCode(
                  currentScope,
                  finallyContext = new FinallyFlowContext(flowContext, finallyBlock),
                  flowInfo.copy().unconditionalInits().discardNullRelatedInitializations())
              .unconditionalInits();
      if (subInfo == FlowInfo.DEAD_END) {
        isSubRoutineEscaping = true;
        scope.problemReporter().finallyMustCompleteNormally(finallyBlock);
      }
      this.subRoutineInits = subInfo;
    }
    // process the try block in a context handling the local exceptions.
    ExceptionHandlingFlowContext handlingContext =
        new ExceptionHandlingFlowContext(
            insideSubContext == null ? flowContext : insideSubContext,
            tryBlock,
            caughtExceptionTypes,
            scope,
            flowInfo.unconditionalInits());

    FlowInfo tryInfo;
    if (tryBlock.isEmptyBlock()) {
      tryInfo = flowInfo;
      tryBlockExit = false;
    } else {
      tryInfo = tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
      tryBlockExit = !tryInfo.isReachable();
    }

    // check unreachable catch blocks
    handlingContext.complainIfUnusedExceptionHandlers(scope, this);

    // process the catch blocks - computing the minimal exit depth amongst try/catch
    if (catchArguments != null) {
      int catchCount;
      catchExits = new boolean[catchCount = catchBlocks.length];
      for (int i = 0; i < catchCount; i++) {
        // keep track of the inits that could potentially have led to this exception handler (for
        // final assignments diagnosis)
        FlowInfo catchInfo =
            flowInfo
                .copy()
                .unconditionalInits()
                .addPotentialInitializationsFrom(
                    handlingContext.initsOnException(caughtExceptionTypes[i]).unconditionalInits())
                .addPotentialInitializationsFrom(tryInfo.unconditionalInits())
                .addPotentialInitializationsFrom(handlingContext.initsOnReturn);

        // catch var is always set
        LocalVariableBinding catchArg = catchArguments[i].binding;
        FlowContext catchContext = insideSubContext == null ? flowContext : insideSubContext;
        catchInfo.markAsDefinitelyAssigned(catchArg);
        catchInfo.markAsDefinitelyNonNull(catchArg);
        /*
        "If we are about to consider an unchecked exception handler, potential inits may have occured inside
        the try block that need to be detected , e.g.
        try { x = 1; throwSomething();} catch(Exception e){ x = 2} "
        "(uncheckedExceptionTypes notNil and: [uncheckedExceptionTypes at: index])
        ifTrue: [catchInits addPotentialInitializationsFrom: tryInits]."
        */
        if (tryBlock.statements == null) {
          catchInfo.setReachMode(FlowInfo.UNREACHABLE);
        }
        catchInfo = catchBlocks[i].analyseCode(currentScope, catchContext, catchInfo);
        catchExits[i] = !catchInfo.isReachable();
        tryInfo = tryInfo.mergedWith(catchInfo.unconditionalInits());
      }
    }
    if (subRoutineStartLabel == null) {
      mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);
      return tryInfo;
    }

    // we also need to check potential multiple assignments of final variables inside the finally
    // block
    // need to include potential inits from returns inside the try/catch parts - 1GK2AOF
    finallyContext.complainOnDeferredChecks(
        tryInfo.isReachable()
            ? (tryInfo.addPotentialInitializationsFrom(insideSubContext.initsOnReturn))
            : insideSubContext.initsOnReturn,
        currentScope);
    if (subInfo == FlowInfo.DEAD_END) {
      mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(subInfo);
      return subInfo;
    } else {
      FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);
      mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);
      return mergedInfo;
    }
  }
Ejemplo n.º 2
0
  public void resolve(BlockScope upperScope) {

    // special scope for secret locals optimization.
    this.scope = new BlockScope(upperScope);

    BlockScope tryScope = new BlockScope(scope);
    BlockScope finallyScope = null;

    if (finallyBlock != null) {
      if (finallyBlock.isEmptyBlock()) {
        if ((finallyBlock.bits & UndocumentedEmptyBlockMASK) != 0) {
          scope
              .problemReporter()
              .undocumentedEmptyBlock(finallyBlock.sourceStart, finallyBlock.sourceEnd);
        }
      } else {
        finallyScope = new BlockScope(scope, false); // don't add it yet to parent scope

        // provision for returning and forcing the finally block to run
        MethodScope methodScope = scope.methodScope();

        // the type does not matter as long as it is not a base type
        if (!upperScope.compilerOptions().inlineJsrBytecode) {
          this.returnAddressVariable =
              new LocalVariableBinding(
                  SecretReturnName, upperScope.getJavaLangObject(), AccDefault, false);
          finallyScope.addLocalVariable(returnAddressVariable);
          this.returnAddressVariable.setConstant(NotAConstant); // not inlinable
        }
        this.subRoutineStartLabel = new Label();

        this.anyExceptionVariable =
            new LocalVariableBinding(
                SecretAnyHandlerName, scope.getJavaLangThrowable(), AccDefault, false);
        finallyScope.addLocalVariable(this.anyExceptionVariable);
        this.anyExceptionVariable.setConstant(NotAConstant); // not inlinable

        if (!methodScope.isInsideInitializer()) {
          MethodBinding methodBinding =
              ((AbstractMethodDeclaration) methodScope.referenceContext).binding;
          if (methodBinding != null) {
            TypeBinding methodReturnType = methodBinding.returnType;
            if (methodReturnType.id != T_void) {
              this.secretReturnValue =
                  new LocalVariableBinding(
                      SecretLocalDeclarationName, methodReturnType, AccDefault, false);
              finallyScope.addLocalVariable(this.secretReturnValue);
              this.secretReturnValue.setConstant(NotAConstant); // not inlinable
            }
          }
        }
        finallyBlock.resolveUsing(finallyScope);
        // force the finally scope to have variable positions shifted after its try scope and catch
        // ones
        finallyScope.shiftScopes =
            new BlockScope[catchArguments == null ? 1 : catchArguments.length + 1];
        finallyScope.shiftScopes[0] = tryScope;
      }
    }
    this.tryBlock.resolveUsing(tryScope);

    // arguments type are checked against JavaLangThrowable in resolveForCatch(..)
    if (this.catchBlocks != null) {
      int length = this.catchArguments.length;
      TypeBinding[] argumentTypes = new TypeBinding[length];
      boolean catchHasError = false;
      for (int i = 0; i < length; i++) {
        BlockScope catchScope = new BlockScope(scope);
        if (finallyScope != null) {
          finallyScope.shiftScopes[i + 1] = catchScope;
        }
        // side effect on catchScope in resolveForCatch(..)
        if ((argumentTypes[i] = catchArguments[i].resolveForCatch(catchScope)) == null) {
          catchHasError = true;
        }
        catchBlocks[i].resolveUsing(catchScope);
      }
      if (catchHasError) {
        return;
      }
      // Verify that the catch clause are ordered in the right way:
      // more specialized first.
      this.caughtExceptionTypes = new ReferenceBinding[length];
      for (int i = 0; i < length; i++) {
        caughtExceptionTypes[i] = (ReferenceBinding) argumentTypes[i];
        for (int j = 0; j < i; j++) {
          if (caughtExceptionTypes[i].isCompatibleWith(argumentTypes[j])) {
            scope
                .problemReporter()
                .wrongSequenceOfExceptionTypesError(
                    this, caughtExceptionTypes[i], i, argumentTypes[j]);
          }
        }
      }
    } else {
      caughtExceptionTypes = new ReferenceBinding[0];
    }

    if (finallyScope != null) {
      // add finallyScope as last subscope, so it can be shifted behind try/catch subscopes.
      // the shifting is necessary to achieve no overlay in between the finally scope and its
      // sibling in term of local variable positions.
      this.scope.addSubscope(finallyScope);
    }
  }
  public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {

    Constant cst = this.left.optimizedBooleanConstant();
    boolean isLeftOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
    boolean isLeftOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;

    if (isLeftOptimizedFalse) {
      // FALSE || anything
      // need to be careful of scenario:
      //		(x || y) || !z, if passing the left info to the right, it would be swapped by the !
      FlowInfo mergedInfo =
          this.left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
      flowContext.expireNullCheckedFieldInfo();
      mergedInfo = this.right.analyseCode(currentScope, flowContext, mergedInfo);
      flowContext.expireNullCheckedFieldInfo();
      this.mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);
      return mergedInfo;
    }

    FlowInfo leftInfo = this.left.analyseCode(currentScope, flowContext, flowInfo);
    flowContext.expireNullCheckedFieldInfo();

    // need to be careful of scenario:
    //		(x || y) || !z, if passing the left info to the right, it would be swapped by the !
    FlowInfo rightInfo = leftInfo.initsWhenFalse().unconditionalCopy();
    this.rightInitStateIndex = currentScope.methodScope().recordInitializationStates(rightInfo);

    int previousMode = rightInfo.reachMode();
    if (isLeftOptimizedTrue) {
      if ((rightInfo.reachMode() & FlowInfo.UNREACHABLE) == 0) {
        currentScope.problemReporter().fakeReachable(this.right);
        rightInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);
      }
    }
    rightInfo = this.right.analyseCode(currentScope, flowContext, rightInfo);
    flowContext.expireNullCheckedFieldInfo();
    if ((this.left.implicitConversion & TypeIds.UNBOXING) != 0) {
      this.left.checkNPE(currentScope, flowContext, flowInfo);
    }
    if ((this.right.implicitConversion & TypeIds.UNBOXING) != 0) {
      this.right.checkNPE(currentScope, flowContext, flowInfo);
    }
    // The definitely null variables in right info when true should not be missed out while merging
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=299900
    FlowInfo leftInfoWhenTrueForMerging =
        leftInfo
            .initsWhenTrue()
            .unconditionalCopy()
            .addPotentialInitializationsFrom(rightInfo.unconditionalInitsWithoutSideEffect());
    FlowInfo mergedInfo =
        FlowInfo.conditional(
            // merging two true initInfos for such a negative case: if ((t && (b = t)) || f) r = b;
            // // b may not have been initialized
            leftInfoWhenTrueForMerging
                .unconditionalInits()
                .mergedWith(
                    rightInfo.safeInitsWhenTrue().setReachMode(previousMode).unconditionalInits()),
            rightInfo.initsWhenFalse());
    this.mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);
    return mergedInfo;
  }
Ejemplo n.º 4
0
  public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
    this.preAssertInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);

    Constant cst = this.assertExpression.optimizedBooleanConstant();
    if ((this.assertExpression.implicitConversion & TypeIds.UNBOXING) != 0) {
      this.assertExpression.checkNPE(currentScope, flowContext, flowInfo);
    }
    boolean isOptimizedTrueAssertion = cst != Constant.NotAConstant && cst.booleanValue() == true;
    boolean isOptimizedFalseAssertion = cst != Constant.NotAConstant && cst.booleanValue() == false;

    flowContext.tagBits |= FlowContext.HIDE_NULL_COMPARISON_WARNING;
    FlowInfo conditionFlowInfo =
        this.assertExpression.analyseCode(currentScope, flowContext, flowInfo.copy());
    flowContext.extendTimeToLiveForNullCheckedField(1); // survive this assert as a Statement
    flowContext.tagBits &= ~FlowContext.HIDE_NULL_COMPARISON_WARNING;
    UnconditionalFlowInfo assertWhenTrueInfo =
        conditionFlowInfo.initsWhenTrue().unconditionalInits();
    FlowInfo assertInfo = conditionFlowInfo.initsWhenFalse();
    if (isOptimizedTrueAssertion) {
      assertInfo.setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);
    }

    if (this.exceptionArgument != null) {
      // only gets evaluated when escaping - results are not taken into account
      FlowInfo exceptionInfo =
          this.exceptionArgument.analyseCode(currentScope, flowContext, assertInfo.copy());

      if (isOptimizedTrueAssertion) {
        currentScope.problemReporter().fakeReachable(this.exceptionArgument);
      } else {
        flowContext.checkExceptionHandlers(
            currentScope.getJavaLangAssertionError(), this, exceptionInfo, currentScope);
      }
    }

    if (!isOptimizedTrueAssertion) {
      // add the assert support in the clinit
      manageSyntheticAccessIfNecessary(currentScope, flowInfo);
    }
    // account for potential AssertionError:
    flowContext.recordAbruptExit();
    if (isOptimizedFalseAssertion) {
      return flowInfo; // if assertions are enabled, the following code will be unreachable
      // change this if we need to carry null analysis results of the assert
      // expression downstream
    } else {
      CompilerOptions compilerOptions = currentScope.compilerOptions();
      if (!compilerOptions.includeNullInfoFromAsserts) {
        // keep just the initializations info, don't include assert's null info
        // merge initialization info's and then add back the null info from flowInfo to
        // make sure that the empty null info of assertInfo doesnt change flowInfo's null info.
        return ((flowInfo.nullInfoLessUnconditionalCopy())
                .mergedWith(assertInfo.nullInfoLessUnconditionalCopy()))
            .addNullInfoFrom(flowInfo);
      }
      return flowInfo
          .mergedWith(assertInfo.nullInfoLessUnconditionalCopy())
          .addInitializationsFrom(assertWhenTrueInfo.discardInitializationInfo());
      // keep the merge from the initial code for the definite assignment
      // analysis, tweak the null part to influence nulls downstream
    }
  }
Ejemplo n.º 5
0
  public TypeBinding resolveType(BlockScope scope) {

    this.constant = Constant.NotAConstant;
    if ((this.targetType = this.type.resolveType(scope, true /* check bounds*/)) == null)
      return null;

    /* https://bugs.eclipse.org/bugs/show_bug.cgi?id=320463
      https://bugs.eclipse.org/bugs/show_bug.cgi?id=312076
      JLS3 15.8.2 forbids the type named in the class literal expression from being a parameterized type.
      And the grammar in 18.1 disallows (where X and Y are some concrete types) constructs of the form
      Outer<X>.class, Outer<X>.Inner.class, Outer.Inner<X>.class, Outer<X>.Inner<Y>.class etc.
      Corollary wise, we should resolve the type of the class literal expression to be a raw type as
      class literals exist only for the raw underlying type.
    */
    LookupEnvironment environment = scope.environment();
    this.targetType =
        environment.convertToRawType(
            this.targetType, true /* force conversion of enclosing types*/);

    if (this.targetType.isArrayType()) {
      ArrayBinding arrayBinding = (ArrayBinding) this.targetType;
      TypeBinding leafComponentType = arrayBinding.leafComponentType;
      if (leafComponentType == TypeBinding.VOID) {
        scope.problemReporter().cannotAllocateVoidArray(this);
        return null;
      } else if (leafComponentType.isTypeVariable()) {
        scope
            .problemReporter()
            .illegalClassLiteralForTypeVariable((TypeVariableBinding) leafComponentType, this);
      }
    } else if (this.targetType.isTypeVariable()) {
      scope
          .problemReporter()
          .illegalClassLiteralForTypeVariable((TypeVariableBinding) this.targetType, this);
    }
    // {ObjectTeams: do we need a RoleClassLiteralAccess?
    if (this.targetType instanceof ReferenceBinding) {
      ReferenceBinding targetRef = (ReferenceBinding) this.targetType;
      if (targetRef.isRole()) {
        if (this.verbatim) {
          this.targetType =
              RoleTypeCreator.maybeWrapUnqualifiedRoleType(scope, this.targetType, this);
        } else {
          SourceTypeBinding site = scope.enclosingSourceType();
          if (scope.methodScope().isStatic // role class literal needs team instance
              && !site.isRole() // static role method are OK.
              && !RoleTypeBinding.isRoleWithExplicitAnchor(this.targetType)) // t.R.class?
          {
            scope.problemReporter().roleClassLiteralLacksTeamInstance(this, targetRef);
            return null;
          }
          ReferenceBinding teamBinding;
          if (RoleTypeBinding.isRoleWithExplicitAnchor(targetRef))
            teamBinding = targetRef.enclosingType();
          else teamBinding = TeamModel.findEnclosingTeamContainingRole(site, targetRef);
          if (teamBinding == null)
            scope.problemReporter().externalizedRoleClassLiteral(this, targetRef);
          else {
            TypeBinding methodType =
                RoleClassLiteralAccess.ensureGetClassMethod(
                    teamBinding.getTeamModel(),
                    targetRef.roleModel); // not affected by visibility check (for resilience)
            this.roleClassLiteralAccess = new RoleClassLiteralAccess(this, methodType);
            this.resolvedType = this.roleClassLiteralAccess.resolveType(scope);
          }
          return this.resolvedType;
        }
      }
    }
    // SH}
    ReferenceBinding classType = scope.getJavaLangClass();
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=328689
    if (scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
      // Integer.class --> Class<Integer>, perform boxing of base types (int.class -->
      // Class<Integer>)
      TypeBinding boxedType = null;
      if (this.targetType.id == T_void) {
        boxedType = environment.getResolvedType(JAVA_LANG_VOID, scope);
      } else {
        boxedType = scope.boxing(this.targetType);
      }
      if (environment.usesNullTypeAnnotations())
        boxedType =
            environment.createAnnotatedType(
                boxedType, new AnnotationBinding[] {environment.getNonNullAnnotation()});
      this.resolvedType =
          environment.createParameterizedType(
              classType, new TypeBinding[] {boxedType}, null /*not a member*/);
    } else {
      this.resolvedType = classType;
    }
    return this.resolvedType;
  }
Ejemplo n.º 6
0
  public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {

    // Consider the try block and catch block so as to compute the intersection of initializations
    // and
    // the minimum exit relative depth amongst all of them. Then consider the subroutine, and append
    // its
    // initialization to the try/catch ones, if the subroutine completes normally. If the subroutine
    // does not
    // complete, then only keep this result for the rest of the analysis

    // process the finally block (subroutine) - create a context for the subroutine

    this.preTryInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);

    if (this.anyExceptionVariable != null) {
      this.anyExceptionVariable.useFlag = LocalVariableBinding.USED;
    }
    if (this.returnAddressVariable != null) { // TODO (philippe) if subroutine is escaping, unused
      this.returnAddressVariable.useFlag = LocalVariableBinding.USED;
    }
    if (this.subRoutineStartLabel == null) {
      // no finally block -- this is a simplified copy of the else part
      // process the try block in a context handling the local exceptions.
      ExceptionHandlingFlowContext handlingContext =
          new ExceptionHandlingFlowContext(
              flowContext,
              this,
              this.caughtExceptionTypes,
              null,
              this.scope,
              flowInfo.unconditionalInits());
      handlingContext.initsOnFinally = new NullInfoRegistry(flowInfo.unconditionalInits());
      // only try blocks initialize that member - may consider creating a
      // separate class if needed

      FlowInfo tryInfo;
      if (this.tryBlock.isEmptyBlock()) {
        tryInfo = flowInfo;
      } else {
        tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
        if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0) this.bits |= ASTNode.IsTryBlockExiting;
      }

      // check unreachable catch blocks
      handlingContext.complainIfUnusedExceptionHandlers(this.scope, this);

      // process the catch blocks - computing the minimal exit depth amongst try/catch
      if (this.catchArguments != null) {
        int catchCount;
        this.catchExits = new boolean[catchCount = this.catchBlocks.length];
        this.catchExitInitStateIndexes = new int[catchCount];
        for (int i = 0; i < catchCount; i++) {
          // keep track of the inits that could potentially have led to this exception handler (for
          // final assignments diagnosis)
          FlowInfo catchInfo;
          if (this.caughtExceptionTypes[i].isUncheckedException(true)) {
            catchInfo =
                handlingContext.initsOnFinally.mitigateNullInfoOf(
                    flowInfo
                        .unconditionalCopy()
                        .addPotentialInitializationsFrom(
                            handlingContext.initsOnException(this.caughtExceptionTypes[i]))
                        .addPotentialInitializationsFrom(tryInfo)
                        .addPotentialInitializationsFrom(handlingContext.initsOnReturn));
          } else {
            FlowInfo initsOnException =
                handlingContext.initsOnException(this.caughtExceptionTypes[i]);
            catchInfo =
                flowInfo
                    .nullInfoLessUnconditionalCopy()
                    .addPotentialInitializationsFrom(initsOnException)
                    .addNullInfoFrom(
                        initsOnException) // null info only from here, this is the only way to enter
                                          // the catch block
                    .addPotentialInitializationsFrom(tryInfo.nullInfoLessUnconditionalCopy())
                    .addPotentialInitializationsFrom(
                        handlingContext.initsOnReturn.nullInfoLessUnconditionalCopy());
          }

          // catch var is always set
          LocalVariableBinding catchArg = this.catchArguments[i].binding;
          catchInfo.markAsDefinitelyAssigned(catchArg);
          catchInfo.markAsDefinitelyNonNull(catchArg);
          /*
          "If we are about to consider an unchecked exception handler, potential inits may have occured inside
          the try block that need to be detected , e.g.
          try { x = 1; throwSomething();} catch(Exception e){ x = 2} "
          "(uncheckedExceptionTypes notNil and: [uncheckedExceptionTypes at: index])
          ifTrue: [catchInits addPotentialInitializationsFrom: tryInits]."
          */
          if (this.tryBlock.statements == null) {
            catchInfo.setReachMode(FlowInfo.UNREACHABLE);
          }
          catchInfo = this.catchBlocks[i].analyseCode(currentScope, flowContext, catchInfo);
          this.catchExitInitStateIndexes[i] =
              currentScope.methodScope().recordInitializationStates(catchInfo);
          this.catchExits[i] = (catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;
          tryInfo = tryInfo.mergedWith(catchInfo.unconditionalInits());
        }
      }
      this.mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(tryInfo);

      // chain up null info registry
      if (flowContext.initsOnFinally != null) {
        flowContext.initsOnFinally.add(handlingContext.initsOnFinally);
      }

      return tryInfo;
    } else {
      InsideSubRoutineFlowContext insideSubContext;
      FinallyFlowContext finallyContext;
      UnconditionalFlowInfo subInfo;
      // analyse finally block first
      insideSubContext = new InsideSubRoutineFlowContext(flowContext, this);

      subInfo =
          this.finallyBlock
              .analyseCode(
                  currentScope,
                  finallyContext = new FinallyFlowContext(flowContext, this.finallyBlock),
                  flowInfo.nullInfoLessUnconditionalCopy())
              .unconditionalInits();
      if (subInfo == FlowInfo.DEAD_END) {
        this.bits |= ASTNode.IsSubRoutineEscaping;
        this.scope.problemReporter().finallyMustCompleteNormally(this.finallyBlock);
      }
      this.subRoutineInits = subInfo;
      // process the try block in a context handling the local exceptions.
      ExceptionHandlingFlowContext handlingContext =
          new ExceptionHandlingFlowContext(
              insideSubContext,
              this,
              this.caughtExceptionTypes,
              null,
              this.scope,
              flowInfo.unconditionalInits());
      handlingContext.initsOnFinally = new NullInfoRegistry(flowInfo.unconditionalInits());
      // only try blocks initialize that member - may consider creating a
      // separate class if needed

      FlowInfo tryInfo;
      if (this.tryBlock.isEmptyBlock()) {
        tryInfo = flowInfo;
      } else {
        tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());
        if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0) this.bits |= ASTNode.IsTryBlockExiting;
      }

      // check unreachable catch blocks
      handlingContext.complainIfUnusedExceptionHandlers(this.scope, this);

      // process the catch blocks - computing the minimal exit depth amongst try/catch
      if (this.catchArguments != null) {
        int catchCount;
        this.catchExits = new boolean[catchCount = this.catchBlocks.length];
        this.catchExitInitStateIndexes = new int[catchCount];
        for (int i = 0; i < catchCount; i++) {
          // keep track of the inits that could potentially have led to this exception handler (for
          // final assignments diagnosis)
          FlowInfo catchInfo;
          if (this.caughtExceptionTypes[i].isUncheckedException(true)) {
            catchInfo =
                handlingContext.initsOnFinally.mitigateNullInfoOf(
                    flowInfo
                        .unconditionalCopy()
                        .addPotentialInitializationsFrom(
                            handlingContext.initsOnException(this.caughtExceptionTypes[i]))
                        .addPotentialInitializationsFrom(tryInfo)
                        .addPotentialInitializationsFrom(handlingContext.initsOnReturn));
          } else {
            FlowInfo initsOnException =
                handlingContext.initsOnException(this.caughtExceptionTypes[i]);
            catchInfo =
                flowInfo
                    .nullInfoLessUnconditionalCopy()
                    .addPotentialInitializationsFrom(initsOnException)
                    .addNullInfoFrom(
                        initsOnException) // null info only from here, this is the only way to enter
                                          // the catch block
                    .addPotentialInitializationsFrom(tryInfo.nullInfoLessUnconditionalCopy())
                    .addPotentialInitializationsFrom(
                        handlingContext.initsOnReturn.nullInfoLessUnconditionalCopy());
          }

          // catch var is always set
          LocalVariableBinding catchArg = this.catchArguments[i].binding;
          catchInfo.markAsDefinitelyAssigned(catchArg);
          catchInfo.markAsDefinitelyNonNull(catchArg);
          /*
          "If we are about to consider an unchecked exception handler, potential inits may have occured inside
          the try block that need to be detected , e.g.
          try { x = 1; throwSomething();} catch(Exception e){ x = 2} "
          "(uncheckedExceptionTypes notNil and: [uncheckedExceptionTypes at: index])
          ifTrue: [catchInits addPotentialInitializationsFrom: tryInits]."
          */
          if (this.tryBlock.statements == null) {
            catchInfo.setReachMode(FlowInfo.UNREACHABLE);
          }
          catchInfo = this.catchBlocks[i].analyseCode(currentScope, insideSubContext, catchInfo);
          this.catchExitInitStateIndexes[i] =
              currentScope.methodScope().recordInitializationStates(catchInfo);
          this.catchExits[i] = (catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;
          tryInfo = tryInfo.mergedWith(catchInfo.unconditionalInits());
        }
      }
      // we also need to check potential multiple assignments of final variables inside the finally
      // block
      // need to include potential inits from returns inside the try/catch parts - 1GK2AOF
      finallyContext.complainOnDeferredChecks(
          handlingContext.initsOnFinally.mitigateNullInfoOf(
              (tryInfo.tagBits & FlowInfo.UNREACHABLE) == 0
                  ? flowInfo
                      .unconditionalCopy()
                      .addPotentialInitializationsFrom(tryInfo)
                      .
                      // lighten the influence of the try block, which may have
                      // exited at any point
                      addPotentialInitializationsFrom(insideSubContext.initsOnReturn)
                  : insideSubContext.initsOnReturn),
          currentScope);

      // chain up null info registry
      if (flowContext.initsOnFinally != null) {
        flowContext.initsOnFinally.add(handlingContext.initsOnFinally);
      }

      this.naturalExitMergeInitStateIndex =
          currentScope.methodScope().recordInitializationStates(tryInfo);
      if (subInfo == FlowInfo.DEAD_END) {
        this.mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(subInfo);
        return subInfo;
      } else {
        FlowInfo mergedInfo = tryInfo.addInitializationsFrom(subInfo);
        this.mergedInitStateIndex =
            currentScope.methodScope().recordInitializationStates(mergedInfo);
        return mergedInfo;
      }
    }
  }