From 4626b4314ce413836d81b562de7297c495315f2a Mon Sep 17 00:00:00 2001 From: Jakub Florek Date: Mon, 17 Mar 2025 11:09:09 +0100 Subject: [PATCH 1/3] Switch to using structs from SwiftLexicalLookup results. --- lib/ASTGen/Sources/ASTGen/LexicalLookup.swift | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift b/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift index 4dbc4df582d05..10dd0663b46aa 100644 --- a/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift +++ b/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift @@ -232,11 +232,11 @@ private func sllConsumedResults( return results.flatMap { result in switch result { - case .lookInMembers(let lookInMembers): + case .lookInMembers(let syntax): return [ ConsumedLookupResult( rawName: "", - position: lookInMembers.lookupMembersPosition, + position: (syntax.asProtocol(SyntaxProtocol.self) as! LookInMembersScopeSyntax).lookupMembersPosition, flags: .shouldLookInMembers ) ] @@ -263,7 +263,7 @@ private func sllConsumedResults( { // If lookup started from inside function attributes, don't reverse. return result.names.map { name in - ConsumedLookupResult(rawName: name.identifier?.name ?? "", position: name.position, flags: []) + ConsumedLookupResult(rawName: name.identifier.name, position: name.position, flags: []) } } else if parent.is(FunctionDeclSyntax.self) || parent.is(SubscriptDeclSyntax.self) || result.scope.range.contains(lookupToken.position) @@ -271,7 +271,7 @@ private func sllConsumedResults( // If a result from function generic parameter clause or lookup started within it, reverse introduced names. return result.names.reversed().map { name in ConsumedLookupResult( - rawName: name.identifier?.name ?? "", + rawName: name.identifier.name, position: name.position, flags: .placementRearranged ) @@ -282,7 +282,7 @@ private func sllConsumedResults( // If lookup started from nominal type inheritance clause, reverse introduced names. return result.names.reversed().map { name in ConsumedLookupResult( - rawName: name.identifier?.name ?? "", + rawName: name.identifier.name, position: name.position, flags: .placementRearranged ) @@ -293,7 +293,7 @@ private func sllConsumedResults( // If lookup from inside the parent initializer decl, reverse introduced names. return result.names.reversed().map { name in ConsumedLookupResult( - rawName: name.identifier?.name ?? "", + rawName: name.identifier.name, position: name.position, flags: .placementRearranged ) @@ -304,7 +304,7 @@ private func sllConsumedResults( // If lookup started from inside type alias initializer, reverse introduced names. return result.names.reversed().map { name in ConsumedLookupResult( - rawName: name.identifier?.name ?? "", + rawName: name.identifier.name, position: name.position, flags: .placementRearranged ) @@ -313,15 +313,15 @@ private func sllConsumedResults( // No flags or reorderings to perform. return result.names.map { name in - ConsumedLookupResult(rawName: name.identifier?.name ?? "", position: name.position, flags: []) + ConsumedLookupResult(rawName: name.identifier.name, position: name.position, flags: []) } } else { return result.names.map { name in // If a Self name not from protocol declaration, should be omitted if no match is found. - let shouldBeOmitted = name.identifier?.name == "Self" ? !result.scope.is(ProtocolDeclSyntax.self) : false + let shouldBeOmitted = name.identifier.name == "Self" ? !result.scope.is(ProtocolDeclSyntax.self) : false return ConsumedLookupResult( - rawName: name.identifier?.name ?? "", + rawName: name.identifier.name, position: name.position, flags: shouldBeOmitted ? [.shouldBeOptionallyOmitted] : [] ) From 47cc198e9538370df6d1c7e077ce027fe0a59796 Mon Sep 17 00:00:00 2001 From: Jakub Florek Date: Mon, 17 Mar 2025 11:10:52 +0100 Subject: [PATCH 2/3] Add support for `SwiftLexicalLookup` caching. --- lib/ASTGen/Sources/ASTGen/LexicalLookup.swift | 20 +++++++++++++++---- lib/ASTGen/Sources/ASTGen/SourceFile.swift | 7 +++++++ 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift b/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift index 10dd0663b46aa..3dc4b80c76db4 100644 --- a/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift +++ b/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift @@ -52,6 +52,15 @@ public func unqualifiedLookup( } let sourceLocationConverter = sourceFile.pointee.sourceLocationConverter let configuredRegions = sourceFile.pointee.configuredRegions(astContext: astContext) + + let lookupCache: LookupCache + + if let sourceFileCache = sourceFile.pointee.lookupCache { + lookupCache = sourceFileCache + } else { + lookupCache = LookupCache(drop: 4) + sourceFile.pointee.lookupCache = lookupCache + } guard let lookupPosition = sourceFile.pointee.position(of: lookupAt), let lookupToken = sourceFileSyntax.token(at: lookupPosition) @@ -70,7 +79,8 @@ public func unqualifiedLookup( let sllResults = sllConsumedResults( lookupToken: lookupToken, finishInSequentialScope: finishInSequentialScope, - configuredRegions: configuredRegions + configuredRegions: configuredRegions, + cache: lookupCache ) // Add header to the output @@ -196,11 +206,13 @@ private func astConsumedResults( private func sllConsumedResults( lookupToken: TokenSyntax, finishInSequentialScope: Bool, - configuredRegions: ConfiguredRegions + configuredRegions: ConfiguredRegions, + cache: LookupCache ) -> [ConsumedLookupResult] { let resultsWithoutMacroReordering = lookupToken.lookup( nil, - with: LookupConfig(finishInSequentialScope: finishInSequentialScope, configuredRegions: configuredRegions) + with: LookupConfig(finishInSequentialScope: finishInSequentialScope, configuredRegions: configuredRegions), + cache: cache ) // Early reordering of macro declaration parameters with its generic parameters. @@ -413,7 +425,7 @@ private func flaggingPass( } // Check if next results at this position should be ignored. If so, set ignoreAt and omit this name. - if sllResult.ignoreNextFromHere && sllResult.position != ignoreAt { + if sllResult.ignoreNextFromHere { ignoreAt = sllResult.position sllResult.flags.insert(.shouldBeOmitted) } diff --git a/lib/ASTGen/Sources/ASTGen/SourceFile.swift b/lib/ASTGen/Sources/ASTGen/SourceFile.swift index 06289ce561d0c..bc1d26a30a096 100644 --- a/lib/ASTGen/Sources/ASTGen/SourceFile.swift +++ b/lib/ASTGen/Sources/ASTGen/SourceFile.swift @@ -16,6 +16,7 @@ import SwiftIfConfig @_spi(ExperimentalLanguageFeatures) import SwiftParser import SwiftParserDiagnostics @_spi(Compiler) import SwiftSyntax +@_spi(Experimental) import SwiftLexicalLookup /// Describes a source file that has been "exported" to the C++ part of the /// compiler, with enough information to interface with the C++ layer. @@ -42,6 +43,12 @@ public struct ExportedSourceFile { /// /// This is a cached value; access via configuredRegions(astContext:). var _configuredRegions: ConfiguredRegions? = nil + + /// Cache used by unqualified lookup + /// + /// Cached so we don't need to re-evaluate common parts + /// of the scope tree during successive lookups. + var lookupCache: LookupCache? = nil public func position(of location: BridgedSourceLoc) -> AbsolutePosition? { let sourceFileBaseAddress = UnsafeRawPointer(buffer.baseAddress!) From 8ebde5dd07ef5f65a81e8b94cf4066759db6521c Mon Sep 17 00:00:00 2001 From: Jakub Florek Date: Tue, 17 Jun 2025 18:22:00 +0200 Subject: [PATCH 3/3] Add new `capacity` parameter when creating new `LookupCache`. Add missing `evictEntriesWithoutHit` call after lookup. --- lib/ASTGen/Sources/ASTGen/LexicalLookup.swift | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift b/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift index 405651f60362b..265fb79b89e61 100644 --- a/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift +++ b/lib/ASTGen/Sources/ASTGen/LexicalLookup.swift @@ -58,7 +58,7 @@ public func unqualifiedLookup( if let sourceFileCache = sourceFile.pointee.lookupCache { lookupCache = sourceFileCache } else { - lookupCache = LookupCache(drop: 4) + lookupCache = LookupCache(capacity: 100, drop: 4) sourceFile.pointee.lookupCache = lookupCache } @@ -214,6 +214,7 @@ private func sllConsumedResults( with: LookupConfig(finishInSequentialScope: finishInSequentialScope, configuredRegions: configuredRegions), cache: cache ) + cache.evictEntriesWithoutHit() // Early reordering of macro declaration parameters with its generic parameters. var results: [LookupResult] = []