src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/LocalVariableTypesCalculator.java

@@ -129,11 +129,10 @@
     }
     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;

@@ -270,51 +269,33 @@
             symbol.setHasSlotFor(type.type);
         }
     }
 
     private static class SymbolConversions {
-        private static final byte I2L = 1 << 0;
-        private static final byte I2D = 1 << 1;
-        private static final byte I2O = 1 << 2;
-        private static final byte L2D = 1 << 3;
-        private static final byte L2O = 1 << 4;
-        private static final byte D2O = 1 << 5;
+        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 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;

@@ -338,30 +319,19 @@
         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);

@@ -376,11 +346,11 @@
         assert type != null;
         final LvarType lvarType = TO_LVAR_TYPE.get(type);
         if(lvarType != null) {
             return lvarType;
         }
-        assert type.isObject();
+        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;