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
118
119
120
121
122
123
124
125
126
127
128
129
|
//===--- GenericParamList.cpp - Swift Language Decl ASTs ------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2018 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
//
//===----------------------------------------------------------------------===//
//
// This file implements the GenericParamList class and related classes.
//
//===----------------------------------------------------------------------===//
#include "swift/AST/GenericParamList.h"
#include "swift/AST/ASTContext.h"
#include "swift/AST/TypeRepr.h"
using namespace swift;
SourceRange RequirementRepr::getSourceRange() const {
if (getKind() == RequirementReprKind::LayoutConstraint)
return SourceRange(FirstType->getSourceRange().Start,
SecondLayout.getSourceRange().End);
return SourceRange(FirstType->getSourceRange().Start,
SecondType->getSourceRange().End);
}
GenericParamList::GenericParamList(SourceLoc LAngleLoc,
ArrayRef<GenericTypeParamDecl *> Params,
SourceLoc WhereLoc,
MutableArrayRef<RequirementRepr> Requirements,
SourceLoc RAngleLoc)
: Brackets(LAngleLoc, RAngleLoc), NumParams(Params.size()),
WhereLoc(WhereLoc), Requirements(Requirements),
OuterParameters(nullptr)
{
std::uninitialized_copy(Params.begin(), Params.end(),
getTrailingObjects<GenericTypeParamDecl *>());
}
GenericParamList *
GenericParamList::create(ASTContext &Context,
SourceLoc LAngleLoc,
ArrayRef<GenericTypeParamDecl *> Params,
SourceLoc RAngleLoc) {
unsigned Size = totalSizeToAlloc<GenericTypeParamDecl *>(Params.size());
void *Mem = Context.Allocate(Size, alignof(GenericParamList));
return new (Mem) GenericParamList(LAngleLoc, Params, SourceLoc(),
MutableArrayRef<RequirementRepr>(),
RAngleLoc);
}
GenericParamList *
GenericParamList::create(const ASTContext &Context,
SourceLoc LAngleLoc,
ArrayRef<GenericTypeParamDecl *> Params,
SourceLoc WhereLoc,
ArrayRef<RequirementRepr> Requirements,
SourceLoc RAngleLoc) {
unsigned Size = totalSizeToAlloc<GenericTypeParamDecl *>(Params.size());
void *Mem = Context.Allocate(Size, alignof(GenericParamList));
return new (Mem) GenericParamList(LAngleLoc, Params,
WhereLoc,
Context.AllocateCopy(Requirements),
RAngleLoc);
}
GenericParamList *
GenericParamList::clone(DeclContext *dc) const {
auto &ctx = dc->getASTContext();
SmallVector<GenericTypeParamDecl *, 2> params;
for (auto param : getParams()) {
auto *newParam = GenericTypeParamDecl::createImplicit(
dc, param->getName(), GenericTypeParamDecl::InvalidDepth,
param->getIndex(), param->isParameterPack(), param->isOpaqueType(),
param->getOpaqueTypeRepr());
params.push_back(newParam);
}
return GenericParamList::create(ctx, SourceLoc(), params, SourceLoc());
}
void GenericParamList::setDepth(unsigned depth) {
for (auto param : *this)
param->setDepth(depth);
}
void GenericParamList::setDeclContext(DeclContext *dc) {
for (auto param : *this)
param->setDeclContext(dc);
}
GenericTypeParamDecl *GenericParamList::lookUpGenericParam(
Identifier name) const {
for (const auto *innerParams = this;
innerParams != nullptr;
innerParams = innerParams->getOuterParameters()) {
for (auto *paramDecl : *innerParams) {
if (name == paramDecl->getName()) {
return const_cast<GenericTypeParamDecl *>(paramDecl);
}
}
}
return nullptr;
}
TrailingWhereClause::TrailingWhereClause(
SourceLoc whereLoc, SourceLoc endLoc,
ArrayRef<RequirementRepr> requirements)
: WhereLoc(whereLoc), EndLoc(endLoc),
NumRequirements(requirements.size())
{
std::uninitialized_copy(requirements.begin(), requirements.end(),
getTrailingObjects<RequirementRepr>());
}
TrailingWhereClause *TrailingWhereClause::create(
ASTContext &ctx,
SourceLoc whereLoc,
SourceLoc endLoc,
ArrayRef<RequirementRepr> requirements) {
unsigned size = totalSizeToAlloc<RequirementRepr>(requirements.size());
void *mem = ctx.Allocate(size, alignof(TrailingWhereClause));
return new (mem) TrailingWhereClause(whereLoc, endLoc, requirements);
}
|
