gt:         final int pp = opt.getProgramPoint();
context: /*
   * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package jdk.nashorn.internal.codegen;
  
  import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid;
  
  import java.util.ArrayDeque;
  import java.util.BitSet;
  import java.util.Deque;
  import jdk.nashorn.internal.ir.AccessNode;
  import jdk.nashorn.internal.ir.BinaryNode;
  import jdk.nashorn.internal.ir.CallNode;
  import jdk.nashorn.internal.ir.CatchNode;
  import jdk.nashorn.internal.ir.Expression;
  import jdk.nashorn.internal.ir.ExpressionStatement;
  import jdk.nashorn.internal.ir.ForNode;
  import jdk.nashorn.internal.ir.FunctionNode;
  import jdk.nashorn.internal.ir.IdentNode;
  import jdk.nashorn.internal.ir.IfNode;
  import jdk.nashorn.internal.ir.IndexNode;
  import jdk.nashorn.internal.ir.JoinPredecessorExpression;
  import jdk.nashorn.internal.ir.LoopNode;
  import jdk.nashorn.internal.ir.Node;
  import jdk.nashorn.internal.ir.Optimistic;
  import jdk.nashorn.internal.ir.PropertyNode;
  import jdk.nashorn.internal.ir.Symbol;
  import jdk.nashorn.internal.ir.TernaryNode;
  import jdk.nashorn.internal.ir.UnaryNode;
  import jdk.nashorn.internal.ir.VarNode;
  import jdk.nashorn.internal.ir.WhileNode;
  import jdk.nashorn.internal.ir.visitor.SimpleNodeVisitor;
  import jdk.nashorn.internal.parser.TokenType;
  import jdk.nashorn.internal.runtime.ScriptObject;
  
  /**
   * Assigns optimistic types to expressions that can have them. This class mainly contains logic for which expressions
   * must not ever be marked as optimistic, assigning narrowest non-invalidated types to program points from the
   * compilation environment, as well as initializing optimistic types of global properties for scripts.
   */
  final class OptimisticTypesCalculator extends SimpleNodeVisitor {
  
      final Compiler compiler;
  
      // Per-function bit set of program points that must never be optimistic.
      final Deque<BitSet> neverOptimistic = new ArrayDeque<>();
  
      OptimisticTypesCalculator(final Compiler compiler) {
          this.compiler = compiler;
      }
  
      @Override
      public boolean enterAccessNode(final AccessNode accessNode) {
          tagNeverOptimistic(accessNode.getBase());
          return true;
      }
  
      @Override
      public boolean enterPropertyNode(final PropertyNode propertyNode) {
          if(ScriptObject.PROTO_PROPERTY_NAME.equals(propertyNode.getKeyName())) {
              tagNeverOptimistic(propertyNode.getValue());
          }
          return super.enterPropertyNode(propertyNode);
      }
  
      @Override
      public boolean enterBinaryNode(final BinaryNode binaryNode) {
          if(binaryNode.isAssignment()) {
              final Expression lhs = binaryNode.lhs();
              if(!binaryNode.isSelfModifying()) {
                  tagNeverOptimistic(lhs);
              }
              if(lhs instanceof IdentNode) {
                  final Symbol symbol = ((IdentNode)lhs).getSymbol();
                  // Assignment to internal symbols is never optimistic, except for self-assignment expressions
                  if(symbol.isInternal() && !binaryNode.rhs().isSelfModifying()) {
                      tagNeverOptimistic(binaryNode.rhs());
                  }
              }
          } else if(binaryNode.isTokenType(TokenType.INSTANCEOF)
                  || binaryNode.isTokenType(TokenType.EQ_STRICT)
                  || binaryNode.isTokenType(TokenType.NE_STRICT)) {
              tagNeverOptimistic(binaryNode.lhs());
              tagNeverOptimistic(binaryNode.rhs());
          }
          return true;
      }
  
      @Override
      public boolean enterCallNode(final CallNode callNode) {
          tagNeverOptimistic(callNode.getFunction());
          return true;
      }
  
      @Override
      public boolean enterCatchNode(final CatchNode catchNode) {
          // Condition is never optimistic (always coerced to boolean).
          tagNeverOptimistic(catchNode.getExceptionCondition());
          return true;
      }
  
      @Override
      public boolean enterExpressionStatement(final ExpressionStatement expressionStatement) {
          final Expression expr = expressionStatement.getExpression();
          if(!expr.isSelfModifying()) {
              tagNeverOptimistic(expr);
          }
          return true;
      }
  
      @Override
      public boolean enterForNode(final ForNode forNode) {
          if(forNode.isForInOrOf()) {
              // for..in has the iterable in its "modify"
              tagNeverOptimistic(forNode.getModify());
          } else {
              // Test is never optimistic (always coerced to boolean).
              tagNeverOptimisticLoopTest(forNode);
          }
          return true;
      }
  
      @Override
      public boolean enterFunctionNode(final FunctionNode functionNode) {
          if (!neverOptimistic.isEmpty() && compiler.isOnDemandCompilation()) {
              // This is a nested function, and we're doing on-demand compilation. In these compilations, we never descend
              // into nested functions.
              return false;
          }
          neverOptimistic.push(new BitSet());
          return true;
      }
  
      @Override
      public boolean enterIfNode(final IfNode ifNode) {
          // Test is never optimistic (always coerced to boolean).
          tagNeverOptimistic(ifNode.getTest());
          return true;
      }
  
      @Override
      public boolean enterIndexNode(final IndexNode indexNode) {
          tagNeverOptimistic(indexNode.getBase());
          return true;
      }
  
      @Override
      public boolean enterTernaryNode(final TernaryNode ternaryNode) {
          // Test is never optimistic (always coerced to boolean).
          tagNeverOptimistic(ternaryNode.getTest());
          return true;
      }
  
      @Override
      public boolean enterUnaryNode(final UnaryNode unaryNode) {
          if(unaryNode.isTokenType(TokenType.NOT) || unaryNode.isTokenType(TokenType.NEW)) {
              // Operand of boolean negation is never optimistic (always coerced to boolean).
              // Operand of "new" is never optimistic (always coerced to Object).
              tagNeverOptimistic(unaryNode.getExpression());
          }
          return true;
      }
  
      @Override
      public boolean enterVarNode(final VarNode varNode) {
          tagNeverOptimistic(varNode.getName());
          return true;
      }
  
      @Override
      public boolean enterWhileNode(final WhileNode whileNode) {
          // Test is never optimistic (always coerced to boolean).
          tagNeverOptimisticLoopTest(whileNode);
          return true;
      }
  
      @Override
      protected Node leaveDefault(final Node node) {
          if(node instanceof Optimistic) {
              return leaveOptimistic((Optimistic)node);
          }
          return node;
      }
  
      @Override
      public Node leaveFunctionNode(final FunctionNode functionNode) {
          neverOptimistic.pop();
          return functionNode;
      }
  
      @Override
      public Node leaveIdentNode(final IdentNode identNode) {
          final Symbol symbol = identNode.getSymbol();
          if(symbol == null) {
              assert identNode.isPropertyName();
              return identNode;
          } else if(symbol.isBytecodeLocal()) {
              // Identifiers accessing bytecode local variables will never be optimistic, as type calculation phase over
              // them will always assign them statically provable types. Note that access to function parameters can still
              // be optimistic if the parameter needs to be in scope as it's used by a nested function.
              return identNode;
          } else if(symbol.isParam() && lc.getCurrentFunction().isVarArg()) {
              // Parameters in vararg methods are not optimistic; we always access them using Object getters.
              return identNode.setType(identNode.getMostPessimisticType());
          } else {
              assert symbol.isScope();
              return leaveOptimistic(identNode);
          }
      }
  
      private Expression leaveOptimistic(final Optimistic opt) {
  