src/jdk/nashorn/internal/codegen/LocalVariableTypesCalculator.java

*** 129,139 ****
      }
      private enum LvarType {
          UNDEFINED(Type.UNDEFINED),
          BOOLEAN(Type.BOOLEAN),
          INT(Type.INT),
-         LONG(Type.LONG),
          DOUBLE(Type.NUMBER),
          OBJECT(Type.OBJECT);
  
          private final Type type;
          private final TypeHolderExpression typeExpression;
--- 129,138 ----
*** 270,320 ****
              symbol.setHasSlotFor(type.type);
          }
      }
  
      private static class SymbolConversions {
!         private static byte I2L = 1 << 0;
!         private static byte I2D = 1 << 1;
!         private static byte I2O = 1 << 2;
!         private static byte L2D = 1 << 3;
!         private static byte L2O = 1 << 4;
!         private static byte D2O = 1 << 5;
  
          private byte conversions;
  
          void recordConversion(final LvarType from, final LvarType to) {
              switch (from) {
              case UNDEFINED:
                  return;
              case INT:
              case BOOLEAN:
                  switch (to) {
-                 case LONG:
-                     recordConversion(I2L);
-                     return;
                  case DOUBLE:
                      recordConversion(I2D);
                      return;
                  case OBJECT:
                      recordConversion(I2O);
                      return;
                  default:
                      illegalConversion(from, to);
                      return;
                  }
-             case LONG:
-                 switch (to) {
-                 case DOUBLE:
-                     recordConversion(L2D);
-                     return;
-                 case OBJECT:
-                     recordConversion(L2O);
-                     return;
-                 default:
-                     illegalConversion(from, to);
-                     return;
-                 }
              case DOUBLE:
                  if(to == LvarType.OBJECT) {
                      recordConversion(D2O);
                  }
                  return;
--- 269,301 ----
              symbol.setHasSlotFor(type.type);
          }
      }
  
      private static class SymbolConversions {
!         private static final byte I2D = 1 << 0;
!         private static final byte I2O = 1 << 1;
!         private static final byte D2O = 1 << 2;
  
          private byte conversions;
  
          void recordConversion(final LvarType from, final LvarType to) {
              switch (from) {
              case UNDEFINED:
                  return;
              case INT:
              case BOOLEAN:
                  switch (to) {
                  case DOUBLE:
                      recordConversion(I2D);
                      return;
                  case OBJECT:
                      recordConversion(I2O);
                      return;
                  default:
                      illegalConversion(from, to);
                      return;
                  }
              case DOUBLE:
                  if(to == LvarType.OBJECT) {
                      recordConversion(D2O);
                  }
                  return;
*** 338,367 ****
          void calculateTypeLiveness(final Symbol symbol) {
              if(symbol.hasSlotFor(Type.OBJECT)) {
                  if(hasConversion(D2O)) {
                      symbol.setHasSlotFor(Type.NUMBER);
                  }
-                 if(hasConversion(L2O)) {
-                     symbol.setHasSlotFor(Type.LONG);
-                 }
                  if(hasConversion(I2O)) {
                      symbol.setHasSlotFor(Type.INT);
                  }
              }
              if(symbol.hasSlotFor(Type.NUMBER)) {
-                 if(hasConversion(L2D)) {
-                     symbol.setHasSlotFor(Type.LONG);
-                 }
                  if(hasConversion(I2D)) {
                      symbol.setHasSlotFor(Type.INT);
                  }
              }
-             if(symbol.hasSlotFor(Type.LONG)) {
-                 if(hasConversion(I2L)) {
-                     symbol.setHasSlotFor(Type.INT);
-                 }
-             }
          }
      }
  
      private void symbolIsConverted(final Symbol symbol, final LvarType from, final LvarType to) {
          SymbolConversions conversions = symbolConversions.get(symbol);
--- 319,337 ----
*** 376,386 ****
          assert type != null;
          final LvarType lvarType = TO_LVAR_TYPE.get(type);
          if(lvarType != null) {
              return lvarType;
          }
!         assert type.isObject();
          return LvarType.OBJECT;
      }
      private static LvarType widestLvarType(final LvarType t1, final LvarType t2) {
          if(t1 == t2) {
              return t1;
--- 346,356 ----
          assert type != null;
          final LvarType lvarType = TO_LVAR_TYPE.get(type);
          if(lvarType != null) {
              return lvarType;
          }
!         assert type.isObject() : "Unsupported primitive type: " + type;
          return LvarType.OBJECT;
      }
      private static LvarType widestLvarType(final LvarType t1, final LvarType t2) {
          if(t1 == t2) {
              return t1;