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
|
//===--- TypeAccessScopeChecker.h - Computes access for Types ---*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2019 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
//
//===----------------------------------------------------------------------===//
#ifndef SWIFT_SEMA_TYPEACCESSSCOPECHECKER_H
#define SWIFT_SEMA_TYPEACCESSSCOPECHECKER_H
#include "swift/AST/Decl.h"
#include "swift/AST/DeclContext.h"
#include "swift/AST/SourceFile.h"
#include "swift/AST/Type.h"
#include "swift/AST/TypeDeclFinder.h"
#include "swift/AST/TypeRepr.h"
namespace swift {
class SourceFile;
/// Computes the access scope where a Type or TypeRepr is available, which is
/// the intersection of all the scopes where the declarations referenced in the
/// Type or TypeRepr are available.
class TypeAccessScopeChecker {
const SourceFile *File;
bool TreatUsableFromInlineAsPublic;
std::optional<AccessScope> Scope = AccessScope::getPublic();
TypeAccessScopeChecker(const DeclContext *useDC,
bool treatUsableFromInlineAsPublic)
: File(useDC->getParentSourceFile()),
TreatUsableFromInlineAsPublic(treatUsableFromInlineAsPublic) {}
bool visitDecl(const ValueDecl *VD) {
if (isa<GenericTypeParamDecl>(VD))
return true;
auto AS = VD->getFormalAccessScope(File, TreatUsableFromInlineAsPublic);
Scope = Scope->intersectWith(AS);
return Scope.has_value();
}
public:
static std::optional<AccessScope>
getAccessScope(TypeRepr *TR, const DeclContext *useDC,
bool treatUsableFromInlineAsPublic = false) {
TypeAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
TR->walk(DeclRefTypeReprFinder([&](const DeclRefTypeRepr *typeRepr) {
return checker.visitDecl(typeRepr->getBoundDecl());
}));
return checker.Scope;
}
static std::optional<AccessScope>
getAccessScope(Type T, const DeclContext *useDC,
bool treatUsableFromInlineAsPublic = false) {
TypeAccessScopeChecker checker(useDC, treatUsableFromInlineAsPublic);
T.walk(SimpleTypeDeclFinder([&](const ValueDecl *VD) {
if (checker.visitDecl(VD))
return TypeWalker::Action::Continue;
return TypeWalker::Action::Stop;
}));
return checker.Scope;
}
};
} // end namespace swift
#endif
|
