hohn/codeql
1
0
Fork 0
mirror of https://github.com/github/codeql.git synced 2025-12-17 01:03:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

Swift: encapsulate swift::ASTVisitor functionality

Browse Source
This commit is contained in:
Paolo Tranquilli
2022-11-03 17:56:04 +01:00
parent 7c9fffc201
commit cc9dafffde
11 changed files with 263 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
swift/extractor/translators/DeclTranslator.cpp
View File

@@ -66,7 +66,7 @@ codeql::PostfixOperatorDecl DeclTranslator::translatePostfixOperatorDecl(
codeql::InfixOperatorDecl DeclTranslator::translateInfixOperatorDecl(
const swift::InfixOperatorDecl& decl) {
auto entry = createEntry(decl);
entry.precedence_group = dispatcher_.fetchOptionalLabel(decl.getPrecedenceGroup());
entry.precedence_group = dispatcher.fetchOptionalLabel(decl.getPrecedenceGroup());
fillOperatorDecl(decl, entry);
return entry;
}
@@ -91,7 +91,7 @@ codeql::TopLevelCodeDecl DeclTranslator::translateTopLevelCodeDecl(
const swift::TopLevelCodeDecl& decl) {
auto entry = createEntry(decl);
assert(decl.getBody() && "Expect top level code to have body");
entry.body = dispatcher_.fetchLabel(decl.getBody());
entry.body = dispatcher.fetchLabel(decl.getBody());
return entry;
}
@@ -101,8 +101,8 @@ codeql::PatternBindingDecl DeclTranslator::translatePatternBindingDecl(
for (unsigned i = 0; i < decl.getNumPatternEntries(); ++i) {
auto pattern = decl.getPattern(i);
assert(pattern && "Expect pattern binding decl to have all patterns");
entry.patterns.push_back(dispatcher_.fetchLabel(pattern));
entry.inits.push_back(dispatcher_.fetchOptionalLabel(decl.getInit(i)));
entry.patterns.push_back(dispatcher.fetchLabel(pattern));
entry.inits.push_back(dispatcher.fetchOptionalLabel(decl.getInit(i)));
}
return entry;
}
@@ -161,7 +161,7 @@ std::optional<codeql::ProtocolDecl> DeclTranslator::translateProtocolDecl(
codeql::EnumCaseDecl DeclTranslator::translateEnumCaseDecl(const swift::EnumCaseDecl& decl) {
auto entry = createEntry(decl);
entry.elements = dispatcher_.fetchRepeatedLabels(decl.getElements());
entry.elements = dispatcher.fetchRepeatedLabels(decl.getElements());
return entry;
}
@@ -173,7 +173,7 @@ std::optional<codeql::EnumElementDecl> DeclTranslator::translateEnumElementDecl(
}
entry->name = decl.getNameStr().str();
if (decl.hasParameterList()) {
entry->params = dispatcher_.fetchRepeatedLabels(*decl.getParameterList());
entry->params = dispatcher.fetchRepeatedLabels(*decl.getParameterList());
}
fillValueDecl(decl, *entry);
return entry;
@@ -235,9 +235,9 @@ std::optional<codeql::SubscriptDecl> DeclTranslator::translateSubscriptDecl(
if (!entry) {
return std::nullopt;
}
entry->element_type = dispatcher_.fetchLabel(decl.getElementInterfaceType());
entry->element_type = dispatcher.fetchLabel(decl.getElementInterfaceType());
if (auto indices = decl.getIndices()) {
entry->params = dispatcher_.fetchRepeatedLabels(*indices);
entry->params = dispatcher.fetchRepeatedLabels(*indices);
}
fillAbstractStorageDecl(decl, *entry);
return entry;
@@ -245,7 +245,7 @@ std::optional<codeql::SubscriptDecl> DeclTranslator::translateSubscriptDecl(
codeql::ExtensionDecl DeclTranslator::translateExtensionDecl(const swift::ExtensionDecl& decl) {
auto entry = createEntry(decl);
entry.extended_type_decl = dispatcher_.fetchLabel(decl.getExtendedNominal());
entry.extended_type_decl = dispatcher.fetchLabel(decl.getExtendedNominal());
fillGenericContext(decl, entry);
fillIterableDeclContext(decl, entry);
return entry;
@@ -254,8 +254,8 @@ codeql::ExtensionDecl DeclTranslator::translateExtensionDecl(const swift::Extens
codeql::ImportDecl DeclTranslator::translateImportDecl(const swift::ImportDecl& decl) {
auto entry = createEntry(decl);
entry.is_exported = decl.isExported();
entry.imported_module = dispatcher_.fetchOptionalLabel(decl.getModule());
entry.declarations = dispatcher_.fetchRepeatedLabels(decl.getDecls());
entry.imported_module = dispatcher.fetchOptionalLabel(decl.getModule());
entry.declarations = dispatcher.fetchRepeatedLabels(decl.getDecls());
return entry;
}
@@ -271,12 +271,12 @@ std::optional<codeql::ModuleDecl> DeclTranslator::translateModuleDecl(
llvm::SmallVector<swift::ImportedModule> imports;
decl.getImportedModules(imports, K::Default);
for (const auto& import : imports) {
entry->imported_modules.push_back(dispatcher_.fetchLabel(import.importedModule));
entry->imported_modules.push_back(dispatcher.fetchLabel(import.importedModule));
}
imports.clear();
decl.getImportedModules(imports, K::Exported);
for (const auto& import : imports) {
entry->exported_modules.push_back(dispatcher_.fetchLabel(import.importedModule));
entry->exported_modules.push_back(dispatcher.fetchLabel(import.importedModule));
}
fillTypeDecl(decl, *entry);
return entry;
@@ -316,10 +316,10 @@ void DeclTranslator::fillAbstractFunctionDecl(const swift::AbstractFunctionDecl&
codeql::AbstractFunctionDecl& entry) {
assert(decl.hasParameterList() && "Expect functions to have a parameter list");
entry.name = !decl.hasName() ? "(unnamed function decl)" : constructName(decl.getName());
entry.body = dispatcher_.fetchOptionalLabel(decl.getBody());
entry.params = dispatcher_.fetchRepeatedLabels(*decl.getParameters());
entry.body = dispatcher.fetchOptionalLabel(decl.getBody());
entry.params = dispatcher.fetchRepeatedLabels(*decl.getParameters());
auto self = const_cast<swift::ParamDecl* const>(decl.getImplicitSelfDecl());
entry.self_param = dispatcher_.fetchOptionalLabel(self);
entry.self_param = dispatcher.fetchOptionalLabel(self);
fillValueDecl(decl, entry);
fillGenericContext(decl, entry);
}
@@ -333,7 +333,7 @@ void DeclTranslator::fillTypeDecl(const swift::TypeDecl& decl, codeql::TypeDecl&
entry.name = decl.getNameStr().str();
for (auto& typeLoc : decl.getInherited()) {
if (auto type = typeLoc.getType()) {
entry.base_types.push_back(dispatcher_.fetchLabel(type));
entry.base_types.push_back(dispatcher.fetchLabel(type));
}
}
fillValueDecl(decl, entry);
@@ -341,24 +341,24 @@ void DeclTranslator::fillTypeDecl(const swift::TypeDecl& decl, codeql::TypeDecl&
void DeclTranslator::fillIterableDeclContext(const swift::IterableDeclContext& decl,
codeql::IterableDeclContext& entry) {
entry.members = dispatcher_.fetchRepeatedLabels(decl.getAllMembers());
entry.members = dispatcher.fetchRepeatedLabels(decl.getAllMembers());
}
void DeclTranslator::fillVarDecl(const swift::VarDecl& decl, codeql::VarDecl& entry) {
entry.name = decl.getNameStr().str();
entry.type = dispatcher_.fetchLabel(decl.getType());
entry.parent_pattern = dispatcher_.fetchOptionalLabel(decl.getParentPattern());
entry.parent_initializer = dispatcher_.fetchOptionalLabel(decl.getParentInitializer());
entry.type = dispatcher.fetchLabel(decl.getType());
entry.parent_pattern = dispatcher.fetchOptionalLabel(decl.getParentPattern());
entry.parent_initializer = dispatcher.fetchOptionalLabel(decl.getParentInitializer());
if (decl.hasAttachedPropertyWrapper()) {
entry.attached_property_wrapper_type =
dispatcher_.fetchOptionalLabel(decl.getPropertyWrapperBackingPropertyType());
dispatcher.fetchOptionalLabel(decl.getPropertyWrapperBackingPropertyType());
}
fillAbstractStorageDecl(decl, entry);
}
void DeclTranslator::fillNominalTypeDecl(const swift::NominalTypeDecl& decl,
codeql::NominalTypeDecl& entry) {
entry.type = dispatcher_.fetchLabel(decl.getDeclaredType());
entry.type = dispatcher.fetchLabel(decl.getDeclaredType());
fillGenericContext(decl, entry);
fillIterableDeclContext(decl, entry);
fillTypeDecl(decl, entry);
@@ -367,25 +367,25 @@ void DeclTranslator::fillNominalTypeDecl(const swift::NominalTypeDecl& decl,
void DeclTranslator::fillGenericContext(const swift::GenericContext& decl,
codeql::GenericContext& entry) {
if (auto params = decl.getGenericParams()) {
entry.generic_type_params = dispatcher_.fetchRepeatedLabels(*params);
entry.generic_type_params = dispatcher.fetchRepeatedLabels(*params);
}
}
void DeclTranslator::fillValueDecl(const swift::ValueDecl& decl, codeql::ValueDecl& entry) {
assert(decl.getInterfaceType() && "Expect ValueDecl to have InterfaceType");
entry.interface_type = dispatcher_.fetchLabel(decl.getInterfaceType());
entry.interface_type = dispatcher.fetchLabel(decl.getInterfaceType());
}
void DeclTranslator::fillAbstractStorageDecl(const swift::AbstractStorageDecl& decl,
codeql::AbstractStorageDecl& entry) {
entry.accessor_decls = dispatcher_.fetchRepeatedLabels(decl.getAllAccessors());
entry.accessor_decls = dispatcher.fetchRepeatedLabels(decl.getAllAccessors());
fillValueDecl(decl, entry);
}
codeql::IfConfigDecl DeclTranslator::translateIfConfigDecl(const swift::IfConfigDecl& decl) {
auto entry = createEntry(decl);
if (auto activeClause = decl.getActiveClause()) {
entry.active_elements = dispatcher_.fetchRepeatedLabels(activeClause->Elements);
entry.active_elements = dispatcher.fetchRepeatedLabels(activeClause->Elements);
}
return entry;
}

9
swift/extractor/translators/DeclTranslator.h
View File

@@ -14,7 +14,6 @@ namespace codeql {
class DeclTranslator : public AstTranslatorBase<DeclTranslator> {
public:
using AstTranslatorBase<DeclTranslator>::AstTranslatorBase;
using AstTranslatorBase<DeclTranslator>::visit;
std::optional<codeql::ConcreteFuncDecl> translateFuncDecl(const swift::FuncDecl& decl);
std::optional<codeql::ConstructorDecl> translateConstructorDecl(
@@ -64,9 +63,9 @@ class DeclTranslator : public AstTranslatorBase<DeclTranslator> {
template <typename D>
std::optional<TrapClassOf<D>> createNamedEntry(const D& decl) {
auto id = dispatcher_.assignNewLabel(decl, mangledName(decl));
auto id = dispatcher.assignNewLabel(decl, mangledName(decl));
std::optional<TrapClassOf<D>> entry;
if (dispatcher_.shouldEmitDeclBody(decl)) {
if (dispatcher.shouldEmitDeclBody(decl)) {
entry.emplace(id);
fillDecl(decl, *entry);
}
@@ -75,13 +74,13 @@ class DeclTranslator : public AstTranslatorBase<DeclTranslator> {
template <typename D>
TrapClassOf<D> createEntry(const D& decl) {
TrapClassOf<D> entry{dispatcher_.template assignNewLabel(decl)};
TrapClassOf<D> entry{dispatcher.template assignNewLabel(decl)};
fillDecl(decl, entry);
return entry;
}
void fillDecl(const swift::Decl& decl, codeql::Decl& entry) {
entry.module = dispatcher_.fetchLabel(decl.getModuleContext());
entry.module = dispatcher.fetchLabel(decl.getModuleContext());
}
swift::Mangle::ASTMangler mangler;

132
swift/extractor/translators/ExprTranslator.cpp
View File

@@ -57,12 +57,12 @@ codeql::StringLiteralExpr ExprTranslator::translateStringLiteralExpr(
codeql::InterpolatedStringLiteralExpr ExprTranslator::translateInterpolatedStringLiteralExpr(
const swift::InterpolatedStringLiteralExpr& expr) {
auto entry = createExprEntry(expr);
entry.interpolation_expr = dispatcher_.fetchOptionalLabel(expr.getInterpolationExpr());
entry.interpolation_expr = dispatcher.fetchOptionalLabel(expr.getInterpolationExpr());
// TODO we should be extracting getInterpolationCount and getLiteralCapacity directly to ints
// these expressions here are just an internal thing, the ints are actually directly available
entry.interpolation_count_expr = dispatcher_.fetchOptionalLabel(expr.getInterpolationCountExpr());
entry.literal_capacity_expr = dispatcher_.fetchOptionalLabel(expr.getLiteralCapacityExpr());
entry.appending_expr = dispatcher_.fetchOptionalLabel(expr.getAppendingExpr());
entry.interpolation_count_expr = dispatcher.fetchOptionalLabel(expr.getInterpolationCountExpr());
entry.literal_capacity_expr = dispatcher.fetchOptionalLabel(expr.getLiteralCapacityExpr());
entry.appending_expr = dispatcher.fetchOptionalLabel(expr.getAppendingExpr());
return entry;
}
@@ -86,33 +86,33 @@ codeql::PrefixUnaryExpr ExprTranslator::translatePrefixUnaryExpr(
codeql::DeclRefExpr ExprTranslator::translateDeclRefExpr(const swift::DeclRefExpr& expr) {
auto entry = createExprEntry(expr);
entry.decl = dispatcher_.fetchLabel(expr.getDecl());
entry.decl = dispatcher.fetchLabel(expr.getDecl());
fillAccessorSemantics(expr, entry);
entry.replacement_types =
dispatcher_.fetchRepeatedLabels(expr.getDeclRef().getSubstitutions().getReplacementTypes());
dispatcher.fetchRepeatedLabels(expr.getDeclRef().getSubstitutions().getReplacementTypes());
return entry;
}
codeql::AssignExpr ExprTranslator::translateAssignExpr(const swift::AssignExpr& expr) {
auto entry = createExprEntry(expr);
entry.dest = dispatcher_.fetchLabel(expr.getDest());
entry.source = dispatcher_.fetchLabel(expr.getSrc());
entry.dest = dispatcher.fetchLabel(expr.getDest());
entry.source = dispatcher.fetchLabel(expr.getSrc());
return entry;
}
codeql::BindOptionalExpr ExprTranslator::translateBindOptionalExpr(
const swift::BindOptionalExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
codeql::CaptureListExpr ExprTranslator::translateCaptureListExpr(
const swift::CaptureListExpr& expr) {
auto entry = createExprEntry(expr);
entry.closure_body = dispatcher_.fetchLabel(expr.getClosureBody());
entry.closure_body = dispatcher.fetchLabel(expr.getClosureBody());
for (const auto& item : const_cast<swift::CaptureListExpr&>(expr).getCaptureList()) {
entry.binding_decls.push_back(dispatcher_.fetchLabel(item.PBD));
entry.binding_decls.push_back(dispatcher.fetchLabel(item.PBD));
}
return entry;
}
@@ -125,17 +125,17 @@ codeql::BinaryExpr ExprTranslator::translateBinaryExpr(const swift::BinaryExpr&
codeql::TupleExpr ExprTranslator::translateTupleExpr(const swift::TupleExpr& expr) {
auto entry = createExprEntry(expr);
entry.elements = dispatcher_.fetchRepeatedLabels(expr.getElements());
entry.elements = dispatcher.fetchRepeatedLabels(expr.getElements());
return entry;
}
codeql::DefaultArgumentExpr ExprTranslator::translateDefaultArgumentExpr(
const swift::DefaultArgumentExpr& expr) {
auto entry = createExprEntry(expr);
entry.param_decl = dispatcher_.fetchLabel(expr.getParamDecl());
entry.param_decl = dispatcher.fetchLabel(expr.getParamDecl());
entry.param_index = expr.getParamIndex();
if (expr.isCallerSide()) {
entry.caller_side_default = dispatcher_.fetchLabel(expr.getCallerSideDefaultExpr());
entry.caller_side_default = dispatcher.fetchLabel(expr.getCallerSideDefaultExpr());
}
return entry;
}
@@ -143,75 +143,75 @@ codeql::DefaultArgumentExpr ExprTranslator::translateDefaultArgumentExpr(
codeql::DotSyntaxBaseIgnoredExpr ExprTranslator::translateDotSyntaxBaseIgnoredExpr(
const swift::DotSyntaxBaseIgnoredExpr& expr) {
auto entry = createExprEntry(expr);
entry.qualifier = dispatcher_.fetchLabel(expr.getLHS());
entry.sub_expr = dispatcher_.fetchLabel(expr.getRHS());
entry.qualifier = dispatcher.fetchLabel(expr.getLHS());
entry.sub_expr = dispatcher.fetchLabel(expr.getRHS());
return entry;
}
codeql::DynamicTypeExpr ExprTranslator::translateDynamicTypeExpr(
const swift::DynamicTypeExpr& expr) {
auto entry = createExprEntry(expr);
entry.base = dispatcher_.fetchLabel(expr.getBase());
entry.base = dispatcher.fetchLabel(expr.getBase());
return entry;
}
codeql::EnumIsCaseExpr ExprTranslator::translateEnumIsCaseExpr(const swift::EnumIsCaseExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.element = dispatcher_.fetchLabel(expr.getEnumElement());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
entry.element = dispatcher.fetchLabel(expr.getEnumElement());
return entry;
}
codeql::MakeTemporarilyEscapableExpr ExprTranslator::translateMakeTemporarilyEscapableExpr(
const swift::MakeTemporarilyEscapableExpr& expr) {
auto entry = createExprEntry(expr);
entry.escaping_closure = dispatcher_.fetchLabel(expr.getOpaqueValue());
entry.nonescaping_closure = dispatcher_.fetchLabel(expr.getNonescapingClosureValue());
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.escaping_closure = dispatcher.fetchLabel(expr.getOpaqueValue());
entry.nonescaping_closure = dispatcher.fetchLabel(expr.getNonescapingClosureValue());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
codeql::ObjCSelectorExpr ExprTranslator::translateObjCSelectorExpr(
const swift::ObjCSelectorExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.method = dispatcher_.fetchLabel(expr.getMethod());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
entry.method = dispatcher.fetchLabel(expr.getMethod());
return entry;
}
codeql::OneWayExpr ExprTranslator::translateOneWayExpr(const swift::OneWayExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
codeql::OpenExistentialExpr ExprTranslator::translateOpenExistentialExpr(
const swift::OpenExistentialExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.existential = dispatcher_.fetchLabel(expr.getExistentialValue());
entry.opaque_expr = dispatcher_.fetchLabel(expr.getOpaqueValue());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
entry.existential = dispatcher.fetchLabel(expr.getExistentialValue());
entry.opaque_expr = dispatcher.fetchLabel(expr.getOpaqueValue());
return entry;
}
codeql::OptionalEvaluationExpr ExprTranslator::translateOptionalEvaluationExpr(
const swift::OptionalEvaluationExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
codeql::RebindSelfInConstructorExpr ExprTranslator::translateRebindSelfInConstructorExpr(
const swift::RebindSelfInConstructorExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.self = dispatcher_.fetchLabel(expr.getSelf());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
entry.self = dispatcher.fetchLabel(expr.getSelf());
return entry;
}
codeql::SuperRefExpr ExprTranslator::translateSuperRefExpr(const swift::SuperRefExpr& expr) {
auto entry = createExprEntry(expr);
entry.self = dispatcher_.fetchLabel(expr.getSelf());
entry.self = dispatcher.fetchLabel(expr.getSelf());
return entry;
}
@@ -225,20 +225,20 @@ codeql::DotSyntaxCallExpr ExprTranslator::translateDotSyntaxCallExpr(
codeql::VarargExpansionExpr ExprTranslator::translateVarargExpansionExpr(
const swift::VarargExpansionExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
codeql::ArrayExpr ExprTranslator::translateArrayExpr(const swift::ArrayExpr& expr) {
auto entry = createExprEntry(expr);
entry.elements = dispatcher_.fetchRepeatedLabels(expr.getElements());
entry.elements = dispatcher.fetchRepeatedLabels(expr.getElements());
return entry;
}
codeql::TypeExpr ExprTranslator::translateTypeExpr(const swift::TypeExpr& expr) {
auto entry = createExprEntry(expr);
if (expr.getTypeRepr() && expr.getInstanceType()) {
entry.type_repr = dispatcher_.fetchLabel(expr.getTypeRepr(), expr.getInstanceType());
entry.type_repr = dispatcher.fetchLabel(expr.getTypeRepr(), expr.getInstanceType());
}
return entry;
}
@@ -251,7 +251,7 @@ codeql::ParenExpr ExprTranslator::translateParenExpr(const swift::ParenExpr& exp
codeql::InOutExpr ExprTranslator::translateInOutExpr(const swift::InOutExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
@@ -263,16 +263,16 @@ codeql::OpaqueValueExpr ExprTranslator::translateOpaqueValueExpr(
codeql::TapExpr ExprTranslator::translateTapExpr(const swift::TapExpr& expr) {
auto entry = createExprEntry(expr);
entry.var = dispatcher_.fetchLabel(expr.getVar());
entry.body = dispatcher_.fetchLabel(expr.getBody());
entry.sub_expr = dispatcher_.fetchOptionalLabel(expr.getSubExpr());
entry.var = dispatcher.fetchLabel(expr.getVar());
entry.body = dispatcher.fetchLabel(expr.getBody());
entry.sub_expr = dispatcher.fetchOptionalLabel(expr.getSubExpr());
return entry;
}
codeql::TupleElementExpr ExprTranslator::translateTupleElementExpr(
const swift::TupleElementExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getBase());
entry.sub_expr = dispatcher.fetchLabel(expr.getBase());
entry.index = expr.getFieldNumber();
return entry;
}
@@ -361,7 +361,7 @@ codeql::SubscriptExpr ExprTranslator::translateSubscriptExpr(const swift::Subscr
codeql::DictionaryExpr ExprTranslator::translateDictionaryExpr(const swift::DictionaryExpr& expr) {
auto entry = createExprEntry(expr);
entry.elements = dispatcher_.fetchRepeatedLabels(expr.getElements());
entry.elements = dispatcher.fetchRepeatedLabels(expr.getElements());
return entry;
}
@@ -377,13 +377,13 @@ codeql::KeyPathExpr ExprTranslator::translateKeyPathExpr(const swift::KeyPathExp
// TODO this should be completely redone, as we are using internal stuff here instead of
// extracting expr.getComponents()
if (!expr.isObjC()) {
entry.parsed_path = dispatcher_.fetchOptionalLabel(expr.getParsedPath());
entry.parsed_path = dispatcher.fetchOptionalLabel(expr.getParsedPath());
if (auto rootTypeRepr = expr.getRootType()) {
auto keyPathType = expr.getType()->getAs<swift::BoundGenericClassType>();
assert(keyPathType && "KeyPathExpr must have BoundGenericClassType");
auto keyPathTypeArgs = keyPathType->getGenericArgs();
assert(keyPathTypeArgs.size() != 0 && "KeyPathExpr type must have generic args");
entry.root = dispatcher_.fetchLabel(rootTypeRepr, keyPathTypeArgs[0]);
entry.root = dispatcher.fetchLabel(rootTypeRepr, keyPathTypeArgs[0]);
}
}
return entry;
@@ -392,21 +392,21 @@ codeql::KeyPathExpr ExprTranslator::translateKeyPathExpr(const swift::KeyPathExp
codeql::LazyInitializerExpr ExprTranslator::translateLazyInitializerExpr(
const swift::LazyInitializerExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
codeql::ForceValueExpr ExprTranslator::translateForceValueExpr(const swift::ForceValueExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
codeql::IfExpr ExprTranslator::translateIfExpr(const swift::IfExpr& expr) {
auto entry = createExprEntry(expr);
entry.condition = dispatcher_.fetchLabel(expr.getCondExpr());
entry.then_expr = dispatcher_.fetchLabel(expr.getThenExpr());
entry.else_expr = dispatcher_.fetchLabel(expr.getElseExpr());
entry.condition = dispatcher.fetchLabel(expr.getCondExpr());
entry.then_expr = dispatcher.fetchLabel(expr.getThenExpr());
entry.else_expr = dispatcher.fetchLabel(expr.getElseExpr());
return entry;
}
@@ -418,15 +418,15 @@ codeql::KeyPathDotExpr ExprTranslator::translateKeyPathDotExpr(const swift::KeyP
codeql::KeyPathApplicationExpr ExprTranslator::translateKeyPathApplicationExpr(
const swift::KeyPathApplicationExpr& expr) {
auto entry = createExprEntry(expr);
entry.base = dispatcher_.fetchLabel(expr.getBase());
entry.key_path = dispatcher_.fetchLabel(expr.getKeyPath());
entry.base = dispatcher.fetchLabel(expr.getBase());
entry.key_path = dispatcher.fetchLabel(expr.getKeyPath());
return entry;
}
codeql::OtherConstructorDeclRefExpr ExprTranslator::translateOtherConstructorDeclRefExpr(
const swift::OtherConstructorDeclRefExpr& expr) {
auto entry = createExprEntry(expr);
entry.constructor_decl = dispatcher_.fetchLabel(expr.getDecl());
entry.constructor_decl = dispatcher.fetchLabel(expr.getDecl());
return entry;
}
@@ -443,7 +443,7 @@ codeql::UnresolvedDeclRefExpr ExprTranslator::translateUnresolvedDeclRefExpr(
codeql::UnresolvedDotExpr ExprTranslator::translateUnresolvedDotExpr(
const swift::UnresolvedDotExpr& expr) {
auto entry = createExprEntry(expr);
entry.base = dispatcher_.fetchLabel(expr.getBase());
entry.base = dispatcher.fetchLabel(expr.getBase());
llvm::SmallVector<char> scratch;
entry.name = expr.getName().getString(scratch).str();
return entry;
@@ -459,7 +459,7 @@ codeql::UnresolvedMemberExpr ExprTranslator::translateUnresolvedMemberExpr(
codeql::SequenceExpr ExprTranslator::translateSequenceExpr(const swift::SequenceExpr& expr) {
auto entry = createExprEntry(expr);
entry.elements = dispatcher_.fetchRepeatedLabels(expr.getElements());
entry.elements = dispatcher.fetchRepeatedLabels(expr.getElements());
return entry;
}
@@ -477,34 +477,34 @@ codeql::ErrorExpr ExprTranslator::translateErrorExpr(const swift::ErrorExpr& exp
void ExprTranslator::fillAbstractClosureExpr(const swift::AbstractClosureExpr& expr,
codeql::AbstractClosureExpr& entry) {
assert(expr.getParameters() && "AbstractClosureExpr has getParameters()");
entry.params = dispatcher_.fetchRepeatedLabels(*expr.getParameters());
entry.body = dispatcher_.fetchLabel(expr.getBody());
entry.params = dispatcher.fetchRepeatedLabels(*expr.getParameters());
entry.body = dispatcher.fetchLabel(expr.getBody());
}
TrapLabel<ArgumentTag> ExprTranslator::emitArgument(const swift::Argument& arg) {
auto entry = dispatcher_.createUncachedEntry(arg);
auto entry = dispatcher.createUncachedEntry(arg);
entry.label = arg.getLabel().str().str();
entry.expr = dispatcher_.fetchLabel(arg.getExpr());
dispatcher_.emit(entry);
entry.expr = dispatcher.fetchLabel(arg.getExpr());
dispatcher.emit(entry);
return entry.id;
}
void ExprTranslator::fillExplicitCastExpr(const swift::ExplicitCastExpr& expr,
codeql::ExplicitCastExpr& entry) {
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
}
void ExprTranslator::fillIdentityExpr(const swift::IdentityExpr& expr,
codeql::IdentityExpr& entry) {
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
}
void ExprTranslator::fillAnyTryExpr(const swift::AnyTryExpr& expr, codeql::AnyTryExpr& entry) {
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
}
void ExprTranslator::fillApplyExpr(const swift::ApplyExpr& expr, codeql::ApplyExpr& entry) {
entry.function = dispatcher_.fetchLabel(expr.getFn());
entry.function = dispatcher.fetchLabel(expr.getFn());
assert(expr.getArgs() && "ApplyExpr has getArgs");
for (const auto& arg : *expr.getArgs()) {
entry.arguments.push_back(emitArgument(arg));
@@ -513,21 +513,21 @@ void ExprTranslator::fillApplyExpr(const swift::ApplyExpr& expr, codeql::ApplyEx
void ExprTranslator::fillSelfApplyExpr(const swift::SelfApplyExpr& expr,
codeql::SelfApplyExpr& entry) {
entry.base = dispatcher_.fetchLabel(expr.getBase());
entry.base = dispatcher.fetchLabel(expr.getBase());
fillApplyExpr(expr, entry);
}
void ExprTranslator::fillLookupExpr(const swift::LookupExpr& expr, codeql::LookupExpr& entry) {
entry.base = dispatcher_.fetchLabel(expr.getBase());
entry.base = dispatcher.fetchLabel(expr.getBase());
if (expr.hasDecl()) {
entry.member = dispatcher_.fetchLabel(expr.getDecl().getDecl());
entry.member = dispatcher.fetchLabel(expr.getDecl().getDecl());
}
}
codeql::UnresolvedPatternExpr ExprTranslator::translateUnresolvedPatternExpr(
const swift::UnresolvedPatternExpr& expr) {
auto entry = createExprEntry(expr);
entry.sub_pattern = dispatcher_.fetchLabel(expr.getSubPattern());
entry.sub_pattern = dispatcher.fetchLabel(expr.getSubPattern());
return entry;
}
} // namespace codeql

6
swift/extractor/translators/ExprTranslator.h
View File

@@ -48,7 +48,7 @@ class ExprTranslator : public AstTranslatorBase<ExprTranslator> {
template <typename E>
TrapClassOf<E> translateImplicitConversionExpr(const E& expr) {
auto entry = createExprEntry(expr);
entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
entry.sub_expr = dispatcher.fetchLabel(expr.getSubExpr());
return entry;
}
@@ -112,8 +112,8 @@ class ExprTranslator : public AstTranslatorBase<ExprTranslator> {
template <typename T>
TrapClassOf<T> createExprEntry(const T& expr) {
auto entry = dispatcher_.createEntry(expr);
entry.type = dispatcher_.fetchOptionalLabel(expr.getType());
auto entry = dispatcher.createEntry(expr);
entry.type = dispatcher.fetchOptionalLabel(expr.getType());
return entry;
}
};

48
swift/extractor/translators/PatternTranslator.cpp
View File

@@ -3,80 +3,80 @@
namespace codeql {
codeql::NamedPattern PatternTranslator::translateNamedPattern(const swift::NamedPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
auto entry = dispatcher.createEntry(pattern);
// TODO: in some (but not all) cases, this seems to introduce a duplicate entry
// for example the vars listed in a case stmt have a different pointer than then ones in
// patterns.
// assert(pattern.getDecl() && "expect NamedPattern to have Decl");
// dispatcher_.emit(NamedPatternsTrap{label, pattern.getNameStr().str(),
// dispatcher_.fetchLabel(pattern.getDecl())});
// dispatcher.emit(NamedPatternsTrap{label, pattern.getNameStr().str(),
// dispatcher.fetchLabel(pattern.getDecl())});
entry.name = pattern.getNameStr().str();
return entry;
}
codeql::TypedPattern PatternTranslator::translateTypedPattern(const swift::TypedPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
entry.sub_pattern = dispatcher_.fetchLabel(pattern.getSubPattern());
entry.type_repr = dispatcher_.fetchOptionalLabel(pattern.getTypeRepr(), pattern.getType());
auto entry = dispatcher.createEntry(pattern);
entry.sub_pattern = dispatcher.fetchLabel(pattern.getSubPattern());
entry.type_repr = dispatcher.fetchOptionalLabel(pattern.getTypeRepr(), pattern.getType());
return entry;
}
codeql::TuplePattern PatternTranslator::translateTuplePattern(const swift::TuplePattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
auto entry = dispatcher.createEntry(pattern);
for (const auto& p : pattern.getElements()) {
entry.elements.push_back(dispatcher_.fetchLabel(p.getPattern()));
entry.elements.push_back(dispatcher.fetchLabel(p.getPattern()));
}
return entry;
}
codeql::AnyPattern PatternTranslator::translateAnyPattern(const swift::AnyPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
auto entry = dispatcher.createEntry(pattern);
return entry;
}
codeql::BindingPattern PatternTranslator::translateBindingPattern(
const swift::BindingPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
entry.sub_pattern = dispatcher_.fetchLabel(pattern.getSubPattern());
auto entry = dispatcher.createEntry(pattern);
entry.sub_pattern = dispatcher.fetchLabel(pattern.getSubPattern());
return entry;
}
codeql::EnumElementPattern PatternTranslator::translateEnumElementPattern(
const swift::EnumElementPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
entry.element = dispatcher_.fetchLabel(pattern.getElementDecl());
entry.sub_pattern = dispatcher_.fetchOptionalLabel(pattern.getSubPattern());
auto entry = dispatcher.createEntry(pattern);
entry.element = dispatcher.fetchLabel(pattern.getElementDecl());
entry.sub_pattern = dispatcher.fetchOptionalLabel(pattern.getSubPattern());
return entry;
}
codeql::OptionalSomePattern PatternTranslator::translateOptionalSomePattern(
const swift::OptionalSomePattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
entry.sub_pattern = dispatcher_.fetchLabel(pattern.getSubPattern());
auto entry = dispatcher.createEntry(pattern);
entry.sub_pattern = dispatcher.fetchLabel(pattern.getSubPattern());
return entry;
}
codeql::IsPattern PatternTranslator::translateIsPattern(const swift::IsPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
auto entry = dispatcher.createEntry(pattern);
entry.cast_type_repr =
dispatcher_.fetchOptionalLabel(pattern.getCastTypeRepr(), pattern.getCastType());
entry.sub_pattern = dispatcher_.fetchOptionalLabel(pattern.getSubPattern());
dispatcher.fetchOptionalLabel(pattern.getCastTypeRepr(), pattern.getCastType());
entry.sub_pattern = dispatcher.fetchOptionalLabel(pattern.getSubPattern());
return entry;
}
codeql::ExprPattern PatternTranslator::translateExprPattern(const swift::ExprPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
entry.sub_expr = dispatcher_.fetchLabel(pattern.getSubExpr());
auto entry = dispatcher.createEntry(pattern);
entry.sub_expr = dispatcher.fetchLabel(pattern.getSubExpr());
return entry;
}
codeql::ParenPattern PatternTranslator::translateParenPattern(const swift::ParenPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
entry.sub_pattern = dispatcher_.fetchLabel(pattern.getSubPattern());
auto entry = dispatcher.createEntry(pattern);
entry.sub_pattern = dispatcher.fetchLabel(pattern.getSubPattern());
return entry;
}
codeql::BoolPattern PatternTranslator::translateBoolPattern(const swift::BoolPattern& pattern) {
auto entry = dispatcher_.createEntry(pattern);
auto entry = dispatcher.createEntry(pattern);
entry.value = pattern.getValue();
return entry;
}

122
swift/extractor/translators/StmtTranslator.cpp
View File

@@ -2,67 +2,65 @@
namespace codeql {
codeql::StmtCondition StmtTranslator::translateStmtCondition(const swift::StmtCondition& cond) {
auto entry = dispatcher_.createEntry(cond);
entry.elements = dispatcher_.fetchRepeatedLabels(cond);
return entry;
void StmtTranslator::translateAndEmit(const swift::StmtCondition& cond) {
auto entry = dispatcher.createEntry(cond);
entry.elements = dispatcher.fetchRepeatedLabels(cond);
dispatcher.emit(entry);
}
codeql::ConditionElement StmtTranslator::translateStmtConditionElement(
const swift::StmtConditionElement& element) {
auto entry = dispatcher_.createEntry(element);
void StmtTranslator::translateAndEmit(const swift::StmtConditionElement& element) {
auto entry = dispatcher.createEntry(element);
if (auto boolean = element.getBooleanOrNull()) {
entry.boolean = dispatcher_.fetchLabel(boolean);
entry.boolean = dispatcher.fetchLabel(boolean);
} else if (auto pattern = element.getPatternOrNull()) {
entry.pattern = dispatcher_.fetchLabel(pattern);
entry.initializer = dispatcher_.fetchLabel(element.getInitializer());
entry.pattern = dispatcher.fetchLabel(pattern);
entry.initializer = dispatcher.fetchLabel(element.getInitializer());
}
return entry;
dispatcher.emit(entry);
}
codeql::CaseLabelItem StmtTranslator::translateCaseLabelItem(
const swift::CaseLabelItem& labelItem) {
auto entry = dispatcher_.createEntry(labelItem);
entry.pattern = dispatcher_.fetchLabel(labelItem.getPattern());
entry.guard = dispatcher_.fetchOptionalLabel(labelItem.getGuardExpr());
return entry;
void StmtTranslator::translateAndEmit(const swift::CaseLabelItem& labelItem) {
auto entry = dispatcher.createEntry(labelItem);
entry.pattern = dispatcher.fetchLabel(labelItem.getPattern());
entry.guard = dispatcher.fetchOptionalLabel(labelItem.getGuardExpr());
dispatcher.emit(entry);
}
codeql::BraceStmt StmtTranslator::translateBraceStmt(const swift::BraceStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.elements = dispatcher_.fetchRepeatedLabels(stmt.getElements());
auto entry = dispatcher.createEntry(stmt);
entry.elements = dispatcher.fetchRepeatedLabels(stmt.getElements());
return entry;
}
codeql::ReturnStmt StmtTranslator::translateReturnStmt(const swift::ReturnStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
if (stmt.hasResult()) {
entry.result = dispatcher_.fetchLabel(stmt.getResult());
entry.result = dispatcher.fetchLabel(stmt.getResult());
}
return entry;
}
codeql::ForEachStmt StmtTranslator::translateForEachStmt(const swift::ForEachStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledStmt(stmt, entry);
entry.body = dispatcher_.fetchLabel(stmt.getBody());
entry.sequence = dispatcher_.fetchLabel(stmt.getParsedSequence());
entry.pattern = dispatcher_.fetchLabel(stmt.getPattern());
entry.where = dispatcher_.fetchOptionalLabel(stmt.getWhere());
entry.body = dispatcher.fetchLabel(stmt.getBody());
entry.sequence = dispatcher.fetchLabel(stmt.getParsedSequence());
entry.pattern = dispatcher.fetchLabel(stmt.getPattern());
entry.where = dispatcher.fetchOptionalLabel(stmt.getWhere());
return entry;
}
codeql::IfStmt StmtTranslator::translateIfStmt(const swift::IfStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledConditionalStmt(stmt, entry);
entry.then = dispatcher_.fetchLabel(stmt.getThenStmt());
entry.else_ = dispatcher_.fetchOptionalLabel(stmt.getElseStmt());
entry.then = dispatcher.fetchLabel(stmt.getThenStmt());
entry.else_ = dispatcher.fetchOptionalLabel(stmt.getElseStmt());
return entry;
}
codeql::BreakStmt StmtTranslator::translateBreakStmt(const swift::BreakStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.target = dispatcher_.fetchOptionalLabel(stmt.getTarget());
auto entry = dispatcher.createEntry(stmt);
entry.target = dispatcher.fetchOptionalLabel(stmt.getTarget());
if (auto targetName = stmt.getTargetName(); !targetName.empty()) {
entry.target_name = targetName.str().str();
}
@@ -70,8 +68,8 @@ codeql::BreakStmt StmtTranslator::translateBreakStmt(const swift::BreakStmt& stm
}
codeql::ContinueStmt StmtTranslator::translateContinueStmt(const swift::ContinueStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.target = dispatcher_.fetchOptionalLabel(stmt.getTarget());
auto entry = dispatcher.createEntry(stmt);
entry.target = dispatcher.fetchOptionalLabel(stmt.getTarget());
if (auto targetName = stmt.getTargetName(); !targetName.empty()) {
entry.target_name = targetName.str().str();
}
@@ -79,86 +77,86 @@ codeql::ContinueStmt StmtTranslator::translateContinueStmt(const swift::Continue
}
codeql::WhileStmt StmtTranslator::translateWhileStmt(const swift::WhileStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledConditionalStmt(stmt, entry);
entry.body = dispatcher_.fetchLabel(stmt.getBody());
entry.body = dispatcher.fetchLabel(stmt.getBody());
return entry;
}
codeql::RepeatWhileStmt StmtTranslator::translateRepeatWhileStmt(
const swift::RepeatWhileStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledStmt(stmt, entry);
entry.body = dispatcher_.fetchLabel(stmt.getBody());
entry.condition = dispatcher_.fetchLabel(stmt.getCond());
entry.body = dispatcher.fetchLabel(stmt.getBody());
entry.condition = dispatcher.fetchLabel(stmt.getCond());
return entry;
}
codeql::DoCatchStmt StmtTranslator::translateDoCatchStmt(const swift::DoCatchStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledStmt(stmt, entry);
entry.body = dispatcher_.fetchLabel(stmt.getBody());
entry.catches = dispatcher_.fetchRepeatedLabels(stmt.getCatches());
entry.body = dispatcher.fetchLabel(stmt.getBody());
entry.catches = dispatcher.fetchRepeatedLabels(stmt.getCatches());
return entry;
}
codeql::CaseStmt StmtTranslator::translateCaseStmt(const swift::CaseStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.body = dispatcher_.fetchLabel(stmt.getBody());
entry.labels = dispatcher_.fetchRepeatedLabels(stmt.getCaseLabelItems());
auto entry = dispatcher.createEntry(stmt);
entry.body = dispatcher.fetchLabel(stmt.getBody());
entry.labels = dispatcher.fetchRepeatedLabels(stmt.getCaseLabelItems());
if (stmt.hasCaseBodyVariables()) {
for (auto var : stmt.getCaseBodyVariables()) {
entry.variables.push_back(dispatcher_.fetchLabel(var));
entry.variables.push_back(dispatcher.fetchLabel(var));
}
}
return entry;
}
codeql::GuardStmt StmtTranslator::translateGuardStmt(const swift::GuardStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledConditionalStmt(stmt, entry);
entry.body = dispatcher_.fetchLabel(stmt.getBody());
entry.body = dispatcher.fetchLabel(stmt.getBody());
return entry;
}
codeql::ThrowStmt StmtTranslator::translateThrowStmt(const swift::ThrowStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.sub_expr = dispatcher_.fetchLabel(stmt.getSubExpr());
auto entry = dispatcher.createEntry(stmt);
entry.sub_expr = dispatcher.fetchLabel(stmt.getSubExpr());
return entry;
}
codeql::DeferStmt StmtTranslator::translateDeferStmt(const swift::DeferStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.body = dispatcher_.fetchLabel(stmt.getBodyAsWritten());
auto entry = dispatcher.createEntry(stmt);
entry.body = dispatcher.fetchLabel(stmt.getBodyAsWritten());
return entry;
}
codeql::DoStmt StmtTranslator::translateDoStmt(const swift::DoStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledStmt(stmt, entry);
entry.body = dispatcher_.fetchLabel(stmt.getBody());
entry.body = dispatcher.fetchLabel(stmt.getBody());
return entry;
}
codeql::SwitchStmt StmtTranslator::translateSwitchStmt(const swift::SwitchStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
auto entry = dispatcher.createEntry(stmt);
fillLabeledStmt(stmt, entry);
entry.expr = dispatcher_.fetchLabel(stmt.getSubjectExpr());
entry.cases = dispatcher_.fetchRepeatedLabels(stmt.getCases());
entry.expr = dispatcher.fetchLabel(stmt.getSubjectExpr());
entry.cases = dispatcher.fetchRepeatedLabels(stmt.getCases());
return entry;
}
codeql::FallthroughStmt StmtTranslator::translateFallthroughStmt(
const swift::FallthroughStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.fallthrough_source = dispatcher_.fetchLabel(stmt.getFallthroughSource());
entry.fallthrough_dest = dispatcher_.fetchLabel(stmt.getFallthroughDest());
auto entry = dispatcher.createEntry(stmt);
entry.fallthrough_source = dispatcher.fetchLabel(stmt.getFallthroughSource());
entry.fallthrough_dest = dispatcher.fetchLabel(stmt.getFallthroughDest());
return entry;
}
codeql::YieldStmt StmtTranslator::translateYieldStmt(const swift::YieldStmt& stmt) {
auto entry = dispatcher_.createEntry(stmt);
entry.results = dispatcher_.fetchRepeatedLabels(stmt.getYields());
auto entry = dispatcher.createEntry(stmt);
entry.results = dispatcher.fetchRepeatedLabels(stmt.getYields());
return entry;
}
@@ -172,7 +170,7 @@ void StmtTranslator::fillLabeledConditionalStmt(const swift::LabeledConditionalS
codeql::LabeledConditionalStmt& entry) {
// getCondPointer not provided for const stmt by swift...
entry.condition =
dispatcher_.fetchLabel(const_cast<swift::LabeledConditionalStmt&>(stmt).getCondPointer());
dispatcher.fetchLabel(const_cast<swift::LabeledConditionalStmt&>(stmt).getCondPointer());
fillLabeledStmt(stmt, entry);
}

9
swift/extractor/translators/StmtTranslator.h
View File

@@ -8,11 +8,12 @@ namespace codeql {
class StmtTranslator : public AstTranslatorBase<StmtTranslator> {
public:
using AstTranslatorBase<StmtTranslator>::AstTranslatorBase;
using AstTranslatorBase<StmtTranslator>::translateAndEmit;
void translateAndEmit(const swift::StmtCondition& cond);
void translateAndEmit(const swift::StmtConditionElement& element);
void translateAndEmit(const swift::CaseLabelItem& labelItem);
codeql::StmtCondition translateStmtCondition(const swift::StmtCondition& cond);
codeql::ConditionElement translateStmtConditionElement(
const swift::StmtConditionElement& element);
codeql::CaseLabelItem translateCaseLabelItem(const swift::CaseLabelItem& labelItem);
codeql::BraceStmt translateBraceStmt(const swift::BraceStmt& stmt);
codeql::ReturnStmt translateReturnStmt(const swift::ReturnStmt& stmt);
codeql::ForEachStmt translateForEachStmt(const swift::ForEachStmt& stmt);

24
swift/extractor/translators/SwiftVisitor.h
View File

@@ -21,22 +21,22 @@ class SwiftVisitor : private SwiftDispatcher {
void extract(swift::Token& comment) { emitComment(comment); }
private:
void visit(const swift::Decl* decl) override { declTranslator.visit(decl); }
void visit(const swift::Stmt* stmt) override { stmtTranslator.visit(stmt); }
void visit(const swift::StmtCondition* cond) override {
emit(stmtTranslator.translateStmtCondition(*cond));
}
void visit(const swift::Decl* decl) override { declTranslator.translateAndEmit(decl); }
void visit(const swift::Stmt* stmt) override { stmtTranslator.translateAndEmit(stmt); }
void visit(const swift::StmtCondition* cond) override { stmtTranslator.translateAndEmit(*cond); }
void visit(const swift::StmtConditionElement* element) override {
emit(stmtTranslator.translateStmtConditionElement(*element));
stmtTranslator.translateAndEmit(*element);
}
void visit(const swift::CaseLabelItem* item) override {
emit(stmtTranslator.translateCaseLabelItem(*item));
void visit(const swift::CaseLabelItem* item) override { stmtTranslator.translateAndEmit(*item); }
void visit(const swift::Expr* expr) override { exprTranslator.translateAndEmit(expr); }
void visit(const swift::Pattern* pattern) override {
patternTranslator.translateAndEmit(pattern);
}
void visit(const swift::Expr* expr) override { exprTranslator.visit(expr); }
void visit(const swift::Pattern* pattern) override { patternTranslator.visit(pattern); }
void visit(swift::TypeBase* type) override { typeTranslator.visit(type); }
void visit(swift::TypeBase* type) override { typeTranslator.translateAndEmit(type); }
void visit(const swift::TypeRepr* typeRepr, swift::Type type) override {
emit(typeTranslator.translateTypeRepr(*typeRepr, type));
typeTranslator.translateAndEmit(*typeRepr, type);
}
DeclTranslator declTranslator{*this};

57
swift/extractor/translators/TranslatorBase.h
View File

@@ -10,11 +10,11 @@ namespace codeql {
namespace detail {
class TranslatorBase {
protected:
SwiftDispatcher& dispatcher_;
SwiftDispatcher& dispatcher;
public:
// SwiftDispatcher should outlive this instance
TranslatorBase(SwiftDispatcher& dispatcher) : dispatcher_{dispatcher} {}
TranslatorBase(SwiftDispatcher& dispatcher) : dispatcher{dispatcher} {}
};
// define by macro metaprogramming member checkers
@@ -25,7 +25,7 @@ class TranslatorBase {
\
template <typename T> \
struct HasTranslate##CLASS##KIND<T, decltype((void)std::declval<T>().translate##CLASS##KIND( \
std::declval<swift::CLASS##KIND&>()), \
std::declval<const swift::CLASS##KIND&>()), \
void())> : std::true_type {};
DEFINE_TRANSLATE_CHECKER(Decl, , )
@@ -63,35 +63,37 @@ DEFINE_TRANSLATE_CHECKER(TypeRepr, , )
// Moreover, if the implementation class has translate##CLASS##KIND (that uses generated C++
// classes), for the class of for a parent thereof, we want to use that. We detect that by using the
// type traits HasTranslate##CLASS##KIND defined above
#define DEFINE_VISIT(KIND, CLASS, PARENT) \
public: \
void visit##CLASS##KIND(swift::CLASS##KIND* e) { \
if constexpr (detail::HasTranslate##CLASS##KIND<CrtpSubclass>::value) { \
dispatcher_.emit(static_cast<CrtpSubclass*>(this)->translate##CLASS##KIND(*e)); \
} else if constexpr (detail::HasTranslate##PARENT<CrtpSubclass>::value) { \
dispatcher_.emit(static_cast<CrtpSubclass*>(this)->translate##PARENT(*e)); \
} else { \
dispatcher_.emitUnknown(e); \
} \
#define DEFINE_VISIT(KIND, CLASS, PARENT) \
void visit##CLASS##KIND(swift::CLASS##KIND* e) { \
if constexpr (detail::HasTranslate##CLASS##KIND<CrtpSubclass>::value) { \
dispatcher.emit(static_cast<CrtpSubclass*>(this)->translate##CLASS##KIND(*e)); \
} else if constexpr (detail::HasTranslate##PARENT<CrtpSubclass>::value) { \
dispatcher.emit(static_cast<CrtpSubclass*>(this)->translate##PARENT(*e)); \
} else { \
dispatcher.emitUnknown(e); \
} \
}
// base class for our AST visitors, getting a SwiftDispatcher member and define_visit emission for
// unknown/TBD entities. Like `swift::ASTVisitor`, this uses CRTP (the Curiously Recurring Template
// Pattern)
template <typename CrtpSubclass>
class AstTranslatorBase : public swift::ASTVisitor<CrtpSubclass>, protected detail::TranslatorBase {
class AstTranslatorBase : private swift::ASTVisitor<CrtpSubclass>,
protected detail::TranslatorBase {
public:
using TranslatorBase::TranslatorBase;
// TODO
// swift does not provide const visitors, for the moment we const_cast and promise not to
// change the entities. When all visitors have been turned to translators, we can ditch
// swift::ASTVisitor and roll out our own const-correct TranslatorBase class
// swift does not provide const visitors. The following const_cast is safe, as we privately
// route the visit to translateXXX functions only if they take const references to swift
// entities (see HasTranslate##CLASS##KIND above)
template <typename E>
void visit(const E* entity) {
void translateAndEmit(const E* entity) {
swift::ASTVisitor<CrtpSubclass>::visit(const_cast<E*>(entity));
}
private:
friend class swift::ASTVisitor<CrtpSubclass>;
#define DECL(CLASS, PARENT) DEFINE_VISIT(Decl, CLASS, PARENT)
#include "swift/AST/DeclNodes.def"
@@ -112,20 +114,21 @@ class AstTranslatorBase : public swift::ASTVisitor<CrtpSubclass>, protected deta
// unknown/TBD types. Like `swift::TypeVisitor`, this uses CRTP (the Curiously Recurring Template
// Pattern)
template <typename CrtpSubclass>
class TypeTranslatorBase : public swift::TypeVisitor<CrtpSubclass>,
class TypeTranslatorBase : private swift::TypeVisitor<CrtpSubclass>,
protected detail::TranslatorBase {
public:
using TranslatorBase::TranslatorBase;
// TODO
// swift does not provide const visitors, for the moment we const_cast and promise not to
// change the entities. When all visitors have been turned to translators, we can ditch
// swift::ASTVisitor and roll out our own const-correct TranslatorBase class
template <typename E>
void visit(const E* entity) {
swift::TypeVisitor<CrtpSubclass>::visit(const_cast<E*>(entity));
// swift does not provide const visitors. The following const_cast is safe, as we privately
// route the visit to translateXXX functions only if they take const references to swift
// entities (see HasTranslate##CLASS##KIND above)
void translateAndEmit(const swift::TypeBase* type) {
swift::TypeVisitor<CrtpSubclass>::visit(const_cast<swift::TypeBase*>(type));
}
private:
friend class swift::TypeVisitor<CrtpSubclass>;
#define TYPE(CLASS, PARENT) DEFINE_VISIT(Type, CLASS, PARENT)
#include "swift/AST/TypeNodes.def"
};

59
swift/extractor/translators/TypeTranslator.cpp
View File

@@ -2,11 +2,10 @@
namespace codeql {
codeql::TypeRepr TypeTranslator::translateTypeRepr(const swift::TypeRepr& typeRepr,
swift::Type type) {
auto entry = dispatcher_.createEntry(typeRepr);
entry.type = dispatcher_.fetchLabel(type);
return entry;
void TypeTranslator::translateAndEmit(const swift::TypeRepr& typeRepr, swift::Type type) {
auto entry = dispatcher.createEntry(typeRepr);
entry.type = dispatcher.fetchLabel(type);
dispatcher.emit(entry);
}
codeql::ProtocolType TypeTranslator::translateProtocolType(const swift::ProtocolType& type) {
@@ -42,7 +41,7 @@ codeql::FunctionType TypeTranslator::translateFunctionType(const swift::Function
codeql::TupleType TypeTranslator::translateTupleType(const swift::TupleType& type) {
auto entry = createTypeEntry(type);
for (const auto& e : type.getElements()) {
entry.types.push_back(dispatcher_.fetchLabel(e.getType()));
entry.types.push_back(dispatcher.fetchLabel(e.getType()));
if (e.hasName()) {
entry.names.emplace_back(e.getName().str().str());
} else {
@@ -65,21 +64,21 @@ codeql::ExistentialMetatypeType TypeTranslator::translateExistentialMetatypeType
codeql::TypeAliasType TypeTranslator::translateTypeAliasType(const swift::TypeAliasType& type) {
auto entry = createTypeEntry(type);
entry.decl = dispatcher_.fetchLabel(type.getDecl());
entry.decl = dispatcher.fetchLabel(type.getDecl());
return entry;
}
codeql::DependentMemberType TypeTranslator::translateDependentMemberType(
const swift::DependentMemberType& type) {
auto entry = createTypeEntry(type);
entry.base_type = dispatcher_.fetchLabel(type.getBase());
entry.associated_type_decl = dispatcher_.fetchLabel(type.getAssocType());
entry.base_type = dispatcher.fetchLabel(type.getBase());
entry.associated_type_decl = dispatcher.fetchLabel(type.getAssocType());
return entry;
}
codeql::ParenType TypeTranslator::translateParenType(const swift::ParenType& type) {
auto entry = createTypeEntry(type);
entry.type = dispatcher_.fetchLabel(type.getUnderlyingType());
entry.type = dispatcher.fetchLabel(type.getUnderlyingType());
return entry;
}
@@ -97,8 +96,8 @@ codeql::ArraySliceType TypeTranslator::translateArraySliceType(const swift::Arra
codeql::DictionaryType TypeTranslator::translateDictionaryType(const swift::DictionaryType& type) {
auto entry = createTypeEntry(type);
entry.key_type = dispatcher_.fetchLabel(type.getKeyType());
entry.value_type = dispatcher_.fetchLabel(type.getValueType());
entry.key_type = dispatcher.fetchLabel(type.getKeyType());
entry.value_type = dispatcher.fetchLabel(type.getValueType());
return entry;
}
@@ -106,7 +105,7 @@ codeql::GenericFunctionType TypeTranslator::translateGenericFunctionType(
const swift::GenericFunctionType& type) {
auto entry = createTypeEntry(type);
fillAnyFunctionType(type, entry);
entry.generic_params = dispatcher_.fetchRepeatedLabels(type.getGenericParams());
entry.generic_params = dispatcher.fetchRepeatedLabels(type.getGenericParams());
return entry;
}
@@ -118,7 +117,7 @@ codeql::GenericTypeParamType TypeTranslator::translateGenericTypeParamType(
codeql::LValueType TypeTranslator::translateLValueType(const swift::LValueType& type) {
auto entry = createTypeEntry(type);
entry.object_type = dispatcher_.fetchLabel(type.getObjectType());
entry.object_type = dispatcher.fetchLabel(type.getObjectType());
return entry;
}
@@ -138,14 +137,14 @@ codeql::UnboundGenericType TypeTranslator::translateUnboundGenericType(
void TypeTranslator::fillUnarySyntaxSugarType(const swift::UnarySyntaxSugarType& type,
codeql::UnarySyntaxSugarType& entry) {
entry.base_type = dispatcher_.fetchLabel(type.getBaseType());
entry.base_type = dispatcher.fetchLabel(type.getBaseType());
}
void TypeTranslator::fillAnyFunctionType(const swift::AnyFunctionType& type,
codeql::AnyFunctionType& entry) {
entry.result = dispatcher_.fetchLabel(type.getResult());
entry.result = dispatcher.fetchLabel(type.getResult());
for (const auto& p : type.getParams()) {
entry.param_types.push_back(dispatcher_.fetchLabel(p.getPlainType()));
entry.param_types.push_back(dispatcher.fetchLabel(p.getPlainType()));
if (p.hasLabel()) {
entry.param_labels.emplace_back(p.getLabel().str().str());
} else {
@@ -158,38 +157,38 @@ void TypeTranslator::fillAnyFunctionType(const swift::AnyFunctionType& type,
void TypeTranslator::fillBoundGenericType(const swift::BoundGenericType& type,
codeql::BoundGenericType& entry) {
entry.arg_types = dispatcher_.fetchRepeatedLabels(type.getGenericArgs());
entry.arg_types = dispatcher.fetchRepeatedLabels(type.getGenericArgs());
fillAnyGenericType(type, entry);
}
void TypeTranslator::fillAnyGenericType(const swift::AnyGenericType& type,
codeql::AnyGenericType& entry) {
entry.declaration = dispatcher_.fetchLabel(type.getDecl());
entry.parent = dispatcher_.fetchOptionalLabel(type.getParent());
entry.declaration = dispatcher.fetchLabel(type.getDecl());
entry.parent = dispatcher.fetchOptionalLabel(type.getParent());
}
void TypeTranslator::fillType(const swift::TypeBase& type, codeql::Type& entry) {
entry.name = type.getString();
entry.canonical_type = dispatcher_.fetchLabel(type.getCanonicalType());
entry.canonical_type = dispatcher.fetchLabel(type.getCanonicalType());
}
void TypeTranslator::fillArchetypeType(const swift::ArchetypeType& type, ArchetypeType& entry) {
entry.interface_type = dispatcher_.fetchLabel(type.getInterfaceType());
entry.protocols = dispatcher_.fetchRepeatedLabels(type.getConformsTo());
entry.superclass = dispatcher_.fetchOptionalLabel(type.getSuperclass());
entry.interface_type = dispatcher.fetchLabel(type.getInterfaceType());
entry.protocols = dispatcher.fetchRepeatedLabels(type.getConformsTo());
entry.superclass = dispatcher.fetchOptionalLabel(type.getSuperclass());
}
codeql::ExistentialType TypeTranslator::translateExistentialType(
const swift::ExistentialType& type) {
auto entry = createTypeEntry(type);
entry.constraint = dispatcher_.fetchLabel(type.getConstraintType());
entry.constraint = dispatcher.fetchLabel(type.getConstraintType());
return entry;
}
codeql::DynamicSelfType TypeTranslator::translateDynamicSelfType(
const swift::DynamicSelfType& type) {
auto entry = createTypeEntry(type);
entry.static_self_type = dispatcher_.fetchLabel(type.getSelfType());
entry.static_self_type = dispatcher.fetchLabel(type.getSelfType());
return entry;
}
@@ -202,19 +201,19 @@ codeql::VariadicSequenceType TypeTranslator::translateVariadicSequenceType(
codeql::InOutType TypeTranslator::translateInOutType(const swift::InOutType& type) {
auto entry = createTypeEntry(type);
entry.object_type = dispatcher_.fetchLabel(type.getObjectType());
entry.object_type = dispatcher.fetchLabel(type.getObjectType());
return entry;
}
void TypeTranslator::fillReferenceStorageType(const swift::ReferenceStorageType& type,
codeql::ReferenceStorageType& entry) {
entry.referent_type = dispatcher_.fetchLabel(type.getReferentType());
entry.referent_type = dispatcher.fetchLabel(type.getReferentType());
}
codeql::ProtocolCompositionType TypeTranslator::translateProtocolCompositionType(
const swift::ProtocolCompositionType& type) {
auto entry = createTypeEntry(type);
entry.members = dispatcher_.fetchRepeatedLabels(type.getMembers());
entry.members = dispatcher.fetchRepeatedLabels(type.getMembers());
return entry;
}
@@ -240,7 +239,7 @@ codeql::ModuleType TypeTranslator::translateModuleType(const swift::ModuleType&
key += "|clang";
}
auto entry = createTypeEntry(type, key);
entry.module = dispatcher_.fetchLabel(type.getModule());
entry.module = dispatcher.fetchLabel(type.getModule());
return entry;
}
} // namespace codeql

5
swift/extractor/translators/TypeTranslator.h
View File

@@ -7,8 +7,9 @@ namespace codeql {
class TypeTranslator : public TypeTranslatorBase<TypeTranslator> {
public:
using TypeTranslatorBase<TypeTranslator>::TypeTranslatorBase;
using TypeTranslatorBase<TypeTranslator>::translateAndEmit;
codeql::TypeRepr translateTypeRepr(const swift::TypeRepr& typeRepr, swift::Type type);
void translateAndEmit(const swift::TypeRepr& typeRepr, swift::Type type);
codeql::ProtocolType translateProtocolType(const swift::ProtocolType& type);
codeql::EnumType translateEnumType(const swift::EnumType& type);
@@ -80,7 +81,7 @@ class TypeTranslator : public TypeTranslatorBase<TypeTranslator> {
template <typename T, typename... Args>
auto createTypeEntry(const T& type, const Args&... args) {
auto entry = dispatcher_.createEntry(type, args...);
auto entry = dispatcher.createEntry(type, args...);
fillType(type, entry);
return entry;
}