Parse floats with 'F' or 'f' suffix

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -85,7 +85,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         if (text == null) return null
         val result: Any? = when (expression.getNode().getElementType()) {
             JetNodeTypes.INTEGER_CONSTANT -> parseLong(text)
-            JetNodeTypes.FLOAT_CONSTANT -> parseDouble(text)
+            JetNodeTypes.FLOAT_CONSTANT -> parseFloatingLiteral(text)
             JetNodeTypes.BOOLEAN_CONSTANT -> parseBoolean(text)
             JetNodeTypes.CHARACTER_CONSTANT -> CompileTimeConstantResolver.parseChar(expression)
             JetNodeTypes.NULL -> null
@@ -450,6 +450,13 @@ public fun parseLong(text: String): Long? {
     }
 }
 
+private fun parseFloatingLiteral(text: String): Any? {
+    if (text.toLowerCase().endsWith('f')) {
+        return parseFloat(text)
+    }
+    return parseDouble(text)
+}
+
 private fun parseDouble(text: String): Double? {
     try {
         return java.lang.Double.parseDouble(text)
@@ -459,6 +466,15 @@ private fun parseDouble(text: String): Double? {
     }
 }
 
+private fun parseFloat(text: String): Float? {
+    try {
+        return java.lang.Float.parseFloat(text)
+    }
+    catch (e: NumberFormatException) {
+        return null
+    }
+}
+
 private fun parseBoolean(text: String): Boolean {
     if ("true".equals(text)) {
         return true

compiler/frontend/src/org/jetbrains/jet/lexer/Jet.flex

@@ -95,10 +95,11 @@ BIN_INTEGER_LITERAL=0[Bb]({DIGIT})*
 //FLOAT_LITERAL=(({FLOATING_POINT_LITERAL1})[Ff])|(({FLOATING_POINT_LITERAL2})[Ff])|(({FLOATING_POINT_LITERAL3})[Ff])|(({FLOATING_POINT_LITERAL4})[Ff])
 //DOUBLE_LITERAL=(({FLOATING_POINT_LITERAL1})[Dd]?)|(({FLOATING_POINT_LITERAL2})[Dd]?)|(({FLOATING_POINT_LITERAL3})[Dd]?)|(({FLOATING_POINT_LITERAL4})[Dd])
 DOUBLE_LITERAL={FLOATING_POINT_LITERAL1}|{FLOATING_POINT_LITERAL2}|{FLOATING_POINT_LITERAL3}|{FLOATING_POINT_LITERAL4}
-FLOATING_POINT_LITERAL1=({DIGIT})+"."({DIGIT})+({EXPONENT_PART})?
+FLOATING_POINT_LITERAL1=({DIGIT})+"."({DIGIT})+({EXPONENT_PART})?({FLOATING_POINT_LITERAL_SUFFIX})?
-FLOATING_POINT_LITERAL2="."({DIGIT})+({EXPONENT_PART})?
+FLOATING_POINT_LITERAL2="."({DIGIT})+({EXPONENT_PART})?({FLOATING_POINT_LITERAL_SUFFIX})?
-FLOATING_POINT_LITERAL3=({DIGIT})+({EXPONENT_PART})
+FLOATING_POINT_LITERAL3=({DIGIT})+({EXPONENT_PART})({FLOATING_POINT_LITERAL_SUFFIX})?
-FLOATING_POINT_LITERAL4=({DIGIT})+
+FLOATING_POINT_LITERAL4=({DIGIT})+({FLOATING_POINT_LITERAL_SUFFIX})?
+FLOATING_POINT_LITERAL_SUFFIX=[Ff]
 EXPONENT_PART=[Ee]["+""-"]?({DIGIT})*
 HEX_FLOAT_LITERAL={HEX_SIGNIFICAND}{BINARY_EXPONENT}[Ff]
 //HEX_DOUBLE_LITERAL={HEX_SIGNIFICAND}{BINARY_EXPONENT}[Dd]?

compiler/testData/codegen/box/constants/float.kt

@@ -0,0 +1,18 @@
+fun box(): String {
+    if (1F != 1.toFloat()) return "fail 1"
+    if (1.0F != 1.0.toFloat()) return "fail 2"
+    if (1e1F != 1e1.toFloat()) return "fail 3"
+    if (1.0e1F != 1.0e1.toFloat()) return "fail 4"
+    if (1e-1F != 1e-1.toFloat()) return "fail 5"
+    if (1.0e-1F != 1.0e-1.toFloat()) return "fail 6"
+
+    if (1f != 1.toFloat()) return "fail 7"
+    if (1.0f != 1.0.toFloat()) return "fail 8"
+    if (1e1f != 1e1.toFloat()) return "fail 9"
+    if (1.0e1f != 1.0e1.toFloat()) return "fail 10"
+    if (1e-1f != 1e-1.toFloat()) return "fail 11"
+    if (1.0e-1f != 1.0e-1.toFloat()) return "fail 12"
+
+    return "OK"
+}
+

compiler/testData/diagnostics/tests/evaluate/float.kt

@@ -0,0 +1,10 @@
+val a1: Float = 1F
+val a2: Float = 1.0F
+val a3: Float = 1e-1F
+val a4: Float = 1.0e-1F
+
+val b5: Float = 1f
+val b6: Float = 1.0f
+val b7: Float = 1e-1f
+val b8: Float = 1.0e-1f
+

compiler/testData/evaluate/constant/float.kt

@@ -0,0 +1,25 @@
+package test
+
+// val prop1: 1.0.toFloat()
+val prop1 = 1F
+
+// val prop2: 1.0.toFloat()
+val prop2 = 1.0F
+
+// val prop3: 0.1.toFloat()
+val prop3 = 1e-1F
+
+// val prop4: 0.1.toFloat()
+val prop4 = 1.0e-1F
+
+// val prop5: 1.0.toFloat()
+val prop5 = 1f
+
+// val prop6: 1.0.toFloat()
+val prop6 = 1.0f
+
+// val prop7: 0.1.toFloat()
+val prop7 = 1e-1f
+
+// val prop8: 0.1.toFloat()
+val prop8 = 1.0e-1f

compiler/testData/psi/FloatingPointLiteral.kt

@@ -0,0 +1,20 @@
+val array = array<Any>(
+        1,
+        1.0,
+        1e1,
+        1.0e1,
+        1e-1,
+        1.0e-1,
+        1F,
+        1.0F,
+        1e1F,
+        1.0e1F,
+        1e-1F,
+        1.0e-1F,
+        1f,
+        1.0f,
+        1e1f,
+        1.0e1f,
+        1e-1f,
+        1.0e-1f
+)

compiler/testData/psi/FloatingPointLiteral.txt

@@ -0,0 +1,114 @@
+JetFile: FloatingPointLiteral.kt
+  NAMESPACE_HEADER
+    <empty list>
+  PROPERTY
+    PsiElement(val)('val')
+    PsiWhiteSpace(' ')
+    PsiElement(IDENTIFIER)('array')
+    PsiWhiteSpace(' ')
+    PsiElement(EQ)('=')
+    PsiWhiteSpace(' ')
+    CALL_EXPRESSION
+      REFERENCE_EXPRESSION
+        PsiElement(IDENTIFIER)('array')
+      TYPE_ARGUMENT_LIST
+        PsiElement(LT)('<')
+        TYPE_PROJECTION
+          TYPE_REFERENCE
+            USER_TYPE
+              REFERENCE_EXPRESSION
+                PsiElement(IDENTIFIER)('Any')
+        PsiElement(GT)('>')
+      VALUE_ARGUMENT_LIST
+        PsiElement(LPAR)('(')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          INTEGER_CONSTANT
+            PsiElement(INTEGER_LITERAL)('1')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1e1')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0e1')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1e-1')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0e-1')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1F')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0F')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1e1F')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0e1F')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1e-1F')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0e-1F')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1f')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0f')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1e1f')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0e1f')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1e-1f')
+        PsiElement(COMMA)(',')
+        PsiWhiteSpace('\n        ')
+        VALUE_ARGUMENT
+          FLOAT_CONSTANT
+            PsiElement(FLOAT_CONSTANT)('1.0e-1f')
+        PsiWhiteSpace('\n')
+        PsiElement(RPAR)(')')

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -2749,6 +2749,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 doTest("compiler/testData/diagnostics/tests/evaluate/binaryMinusIndependentExpType.kt");
             }
             
+            @TestMetadata("float.kt")
+            public void testFloat() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/evaluate/float.kt");
+            }
+            
             @TestMetadata("intOverflow.kt")
             public void testIntOverflow() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/evaluate/intOverflow.kt");

compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java

@@ -1384,6 +1384,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             doTest("compiler/testData/codegen/box/constants/constantsInWhen.kt");
         }
         
+        @TestMetadata("float.kt")
+        public void testFloat() throws Exception {
+            doTest("compiler/testData/codegen/box/constants/float.kt");
+        }
+        
     }
     
     @TestMetadata("compiler/testData/codegen/box/controlStructures")

compiler/tests/org/jetbrains/jet/evaluate/EvaluateExpressionTestGenerated.java

@@ -53,6 +53,11 @@ public class EvaluateExpressionTestGenerated extends AbstractEvaluateExpressionT
             doConstantTest("compiler/testData/evaluate/constant/equals.kt");
         }
         
+        @TestMetadata("float.kt")
+        public void testFloat() throws Exception {
+            doConstantTest("compiler/testData/evaluate/constant/float.kt");
+        }
+        
         @TestMetadata("floatsAndDoubles.kt")
         public void testFloatsAndDoubles() throws Exception {
             doConstantTest("compiler/testData/evaluate/constant/floatsAndDoubles.kt");

compiler/tests/org/jetbrains/jet/parsing/JetParsingTestGenerated.java

@@ -162,6 +162,11 @@ public class JetParsingTestGenerated extends AbstractJetParsingTest {
         doParsingTest("compiler/testData/psi/FileStart_ERR.kt");
     }
     
+    @TestMetadata("FloatingPointLiteral.kt")
+    public void testFloatingPointLiteral() throws Exception {
+        doParsingTest("compiler/testData/psi/FloatingPointLiteral.kt");
+    }
+    
     @TestMetadata("ForWithMultiDecl.kt")
     public void testForWithMultiDecl() throws Exception {
         doParsingTest("compiler/testData/psi/ForWithMultiDecl.kt");