1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2024 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import CompletionScoring
import CompletionScoringTestSupport
import Foundation
extension ScoringPerfTests {
struct Module {
var completions: [Completion]
init(
randomness: inout RepeatableRandomNumberGenerator,
moduleProximity: ModuleProximity,
nextGroupID: inout Int
) {
let globalFunctionCount = (5..<50).randomElement(using: &randomness)!
let globalTypesCount = (5..<250).randomElement(using: &randomness)!
let weightedAvailability = WeightedChoices<Availability>([
(0.01, .deprecated),
(0.05, .unavailable),
(0.85, .available),
])
let weightedTypeCompatibility = WeightedChoices<TypeCompatibility>([
(0.10, .invalid),
(0.05, .compatible),
(0.85, .unrelated),
])
let functionCompletions: [Completion] = Array(count: globalFunctionCount) {
let function = SymbolGenerator.shared.randomFunction(using: &randomness)
let typeCompatibility = weightedTypeCompatibility.select(using: &randomness)
let availability = weightedAvailability.select(using: &randomness)
let classification = SemanticClassification(
availability: availability,
completionKind: .function,
flair: [],
moduleProximity: moduleProximity,
popularity: .none,
scopeProximity: .global,
structuralProximity: .inapplicable,
synchronicityCompatibility: .compatible,
typeCompatibility: typeCompatibility
)
return Completion(
filterText: function.filterText,
displayText: function.displayText,
semanticClassification: classification
)
}
let typeCompletions: [Completion] = Array(count: globalTypesCount) {
let text = SymbolGenerator.shared.randomType(using: &randomness)
let typeCompatibility = weightedTypeCompatibility.select(using: &randomness)
let availability = weightedAvailability.select(using: &randomness)
let classification = SemanticClassification(
availability: availability,
completionKind: .function,
flair: [],
moduleProximity: moduleProximity,
popularity: .none,
scopeProximity: .global,
structuralProximity: .inapplicable,
synchronicityCompatibility: .compatible,
typeCompatibility: typeCompatibility
)
let groupID = nextGroupID
nextGroupID += 1
return Completion(
filterText: text,
displayText: text,
semanticClassification: classification,
groupID: groupID
)
}
let initializers: [Completion] = typeCompletions.flatMap { typeCompletion -> [Completion] in
let initializers = SymbolGenerator.shared.randomInitializers(
typeName: typeCompletion.filterText,
using: &randomness
)
return initializers.map { initializer -> Completion in
let typeCompatibility = weightedTypeCompatibility.select(using: &randomness)
let availability = weightedAvailability.select(using: &randomness)
let classification = SemanticClassification(
availability: availability,
completionKind: .initializer,
flair: [],
moduleProximity: moduleProximity,
popularity: .none,
scopeProximity: .global,
structuralProximity: .inapplicable,
synchronicityCompatibility: .compatible,
typeCompatibility: typeCompatibility
)
return Completion(
filterText: initializer.filterText,
displayText: initializer.displayText,
semanticClassification: classification,
groupID: typeCompletion.groupID
)
}
}
self.completions = typeCompletions + functionCompletions + initializers
}
}
}
|
