[ASTGen] Generate FloatLiteralExpr

Author: rintaro

include/swift/AST/ASTBridging.h

@@ -200,10 +200,16 @@ SWIFT_NAME("BridgedASTContext.init(raw:)")
 BRIDGED_INLINE
 BridgedASTContext BridgedASTContext_fromRaw(void * _Nonnull ptr);
 
-SWIFT_NAME("BridgedASTContext.copy(self:string:)")
+SWIFT_NAME("BridgedASTContext.allocate(self:size:alignment:)")
 BRIDGED_INLINE
-BridgedStringRef BridgedASTContext_copyString(BridgedASTContext cContext,
-                                              BridgedStringRef cStr);
+void *_Nullable BridgedASTContext_allocate(BridgedASTContext bridged,
+                                           size_t size, size_t alignment);
+
+SWIFT_NAME("BridgedASTContext.allocateCopy(self:string:)")
+BRIDGED_INLINE
+BridgedStringRef
+BridgedASTContext_allocateCopyString(BridgedASTContext cContext,
+                                     BridgedStringRef cStr);
 
 SWIFT_NAME("BridgedASTContext.getIdentifier(self:_:)")
 BridgedIdentifier BridgedASTContext_getIdentifier(BridgedASTContext cContext,
@@ -1318,6 +1324,12 @@ SWIFT_NAME("BridgedErrorExpr.create(_:loc:)")
 BridgedErrorExpr BridgedErrorExpr_create(BridgedASTContext cContext,
                                          BridgedSourceRange cRange);
 
+SWIFT_NAME("BridgedFloatLiteralExpr.createParsed(_:value:loc:)")
+BridgedFloatLiteralExpr
+BridgedFloatLiteralExpr_createParsed(BridgedASTContext cContext,
+                                     BridgedStringRef cStr,
+                                     BridgedSourceLoc cTokenLoc);
+
 SWIFT_NAME("BridgedForceTryExpr.createParsed(_:tryLoc:subExpr:exclaimLoc:)")
 BridgedForceTryExpr
 BridgedForceTryExpr_createParsed(BridgedASTContext cContext,

include/swift/AST/ASTBridgingImpl.h

@@ -32,8 +32,14 @@ BridgedASTContext BridgedASTContext_fromRaw(void * _Nonnull ptr) {
   return *static_cast<swift::ASTContext *>(ptr);
 }
 
-BridgedStringRef BridgedASTContext_copyString(BridgedASTContext bridged,
-                                              BridgedStringRef cStr) {
+BRIDGED_INLINE
+void *_Nullable BridgedASTContext_allocate(BridgedASTContext bridged,
+                                           size_t size, size_t alignment) {
+  return bridged.unbridged().Allocate(size, alignment);
+}
+
+BridgedStringRef BridgedASTContext_allocateCopyString(BridgedASTContext bridged,
+                                                      BridgedStringRef cStr) {
   return bridged.unbridged().AllocateCopy(cStr.unbridged());
 }
 

lib/AST/Bridging/ExprBridging.cpp

@@ -211,6 +211,15 @@ BridgedForceTryExpr_createParsed(BridgedASTContext cContext,
       cTryLoc.unbridged(), cSubExpr.unbridged(), cExclaimLoc.unbridged());
 }
 
+BridgedFloatLiteralExpr
+BridgedFloatLiteralExpr_createParsed(BridgedASTContext cContext,
+                                     BridgedStringRef cStr,
+                                     BridgedSourceLoc cTokenLoc) {
+  ASTContext &context = cContext.unbridged();
+  return new (context)
+      FloatLiteralExpr(cStr.unbridged(), cTokenLoc.unbridged());
+}
+
 BridgedForcedCheckedCastExpr BridgedForcedCheckedCastExpr_createParsed(
     BridgedASTContext cContext, BridgedSourceLoc cAsLoc,
     BridgedSourceLoc cExclaimLoc, BridgedTypeRepr cType) {
@@ -224,8 +233,8 @@ BridgedIntegerLiteralExpr_createParsed(BridgedASTContext cContext,
                                        BridgedStringRef cStr,
                                        BridgedSourceLoc cTokenLoc) {
   ASTContext &context = cContext.unbridged();
-  auto str = context.AllocateCopy(cStr.unbridged());
-  return new (context) IntegerLiteralExpr(str, cTokenLoc.unbridged());
+  return new (context)
+      IntegerLiteralExpr(cStr.unbridged(), cTokenLoc.unbridged());
 }
 
 BridgedSuperRefExpr

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -42,7 +42,7 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
     // Known implemented kinds.
     case .arrayExpr, .arrowExpr, .assignmentExpr, .awaitExpr, .binaryOperatorExpr,
       .booleanLiteralExpr, .borrowExpr, .closureExpr, .consumeExpr, .copyExpr,
-      .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr,
+      .discardAssignmentExpr, .declReferenceExpr, .dictionaryExpr, .floatLiteralExpr,
       .functionCallExpr, .ifExpr, .integerLiteralExpr, .memberAccessExpr,
       .nilLiteralExpr, .packElementExpr, .packExpansionExpr, .patternExpr,
       .postfixOperatorExpr, .prefixOperatorExpr, .regexLiteralExpr, .sequenceExpr,
@@ -53,11 +53,10 @@ func isExprMigrated(_ node: ExprSyntax) -> Bool {
 
     // Known unimplemented kinds.
     case .asExpr, 
-      .doExpr, .editorPlaceholderExpr, .floatLiteralExpr, .forceUnwrapExpr,
-      .inOutExpr, .infixOperatorExpr, .isExpr, .keyPathExpr,
-      .macroExpansionExpr, .optionalChainingExpr,
-      .postfixIfConfigExpr, .genericSpecializationExpr, .switchExpr,
-      .ternaryExpr:
+      .doExpr, .editorPlaceholderExpr, .forceUnwrapExpr, .inOutExpr,
+      .infixOperatorExpr, .isExpr, .keyPathExpr, .macroExpansionExpr,
+      .optionalChainingExpr, .postfixIfConfigExpr, .genericSpecializationExpr,
+      .switchExpr, .ternaryExpr:
       return false
 
     // Unknown expr kinds.
@@ -113,8 +112,8 @@ extension ASTGenVisitor {
       break
     case .editorPlaceholderExpr:
       break
-    case .floatLiteralExpr:
-      break
+    case .floatLiteralExpr(let node):
+      return self.generate(floatLiteralExpr: node).asExpr
     case .forceUnwrapExpr:
       break
     case .functionCallExpr(let node):

lib/ASTGen/Sources/ASTGen/Literals.swift

@@ -12,7 +12,7 @@
 
 import ASTBridging
 @_spi(Compiler) import SwiftParser
-import SwiftSyntax
+@_spi(RawSyntax) import SwiftSyntax
 @_spi(CompilerInterface) import _CompilerRegexParser
 
 extension ASTGenVisitor {
@@ -215,17 +215,35 @@ extension ASTGenVisitor {
     )
   }
 
-  func generate(integerLiteralExpr node: IntegerLiteralExprSyntax) -> BridgedIntegerLiteralExpr {
-    // FIXME: Avoid 'String' instantiation
-    // FIXME: Strip '_'.
-    var segment = node.literal.text
-    return segment.withBridgedString { bridgedSegment in
-      return .createParsed(
-        ctx,
-        value: bridgedSegment,
-        loc: self.generateSourceLoc(node.literal)
-      )
+  func copyAndStripUnderscores(text: SyntaxText) -> BridgedStringRef {
+    assert(!text.isEmpty)
+    let start = self.ctx.allocate(size: text.count, alignment: 1)!
+      .bindMemory(to: UInt8.self, capacity: text.count)
+    var ptr = start
+    for chr in text where chr != UInt8(ascii: "_") {
+      ptr.initialize(to: chr)
+      ptr += 1
     }
+    return BridgedStringRef(
+      data: start,
+      count: start.distance(to: ptr)
+    )
+  }
+
+  func generate(integerLiteralExpr node: IntegerLiteralExprSyntax) -> BridgedIntegerLiteralExpr {
+    return .createParsed(
+      self.ctx,
+      value: self.copyAndStripUnderscores(text: node.literal.rawText),
+      loc: self.generateSourceLoc(node)
+    )
+  }
+
+  func generate(floatLiteralExpr node: FloatLiteralExprSyntax) -> BridgedFloatLiteralExpr {
+    return .createParsed(
+      self.ctx,
+      value: self.copyAndStripUnderscores(text: node.literal.rawText),
+      loc: self.generateSourceLoc(node)
+    )
   }
 
   func generate(booleanLiteralExpr node: BooleanLiteralExprSyntax) -> BridgedBooleanLiteralExpr {

lib/ASTGen/Sources/ASTGen/Regex.swift

@@ -41,7 +41,7 @@ extension ASTGenVisitor {
       )
       // Copy the regex string to the ASTContext.
       let regexToEmitStr = regexToEmit.withBridgedString {
-        self.ctx.copy(string: $0)
+        self.ctx.allocateCopy(string: $0)
       }
 
       return BridgedRegexLiteralExpr.createParsed(