Swift: refactor PatternVisitor to use translations

redsun82 · redsun82 · commit faf10294edfa · 2022-11-03T18:16:53.000+01:00
diff --git a/swift/extractor/infra/SwiftDispatcher.h b/swift/extractor/infra/SwiftDispatcher.h
@@ -329,7 +329,7 @@ class SwiftDispatcher {
   virtual void visit(const swift::StmtConditionElement* cond) = 0;
   virtual void visit(swift::CaseLabelItem* item) = 0;
   virtual void visit(swift::Expr* expr) = 0;
-  virtual void visit(swift::Pattern* pattern) = 0;
+  virtual void visit(const swift::Pattern* pattern) = 0;
   virtual void visit(swift::TypeRepr* typeRepr, swift::Type type) = 0;
   virtual void visit(swift::TypeBase* type) = 0;
 
diff --git a/swift/extractor/visitors/PatternVisitor.cpp b/swift/extractor/visitors/PatternVisitor.cpp
@@ -2,90 +2,83 @@
 
 namespace codeql {
 
-void PatternVisitor::visitNamedPattern(swift::NamedPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
+codeql::NamedPattern PatternVisitor::translateNamedPattern(const swift::NamedPattern& 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()});
+  //  assert(pattern.getDecl() && "expect NamedPattern to have Decl");
+  //  dispatcher_.emit(NamedPatternsTrap{label, pattern.getNameStr().str(),
+  //                                       dispatcher_.fetchLabel(pattern.getDecl())});
+  entry.name = pattern.getNameStr().str();
+  return entry;
 }
 
-void PatternVisitor::visitTypedPattern(swift::TypedPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  assert(pattern->getSubPattern() && "expect TypedPattern to have a SubPattern");
-  dispatcher_.emit(TypedPatternsTrap{label, dispatcher_.fetchLabel(pattern->getSubPattern())});
-  if (auto typeRepr = pattern->getTypeRepr()) {
-    dispatcher_.emit(TypedPatternTypeReprsTrap{
-        label, dispatcher_.fetchLabel(pattern->getTypeRepr(), pattern->getType())});
-  }
+codeql::TypedPattern PatternVisitor::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());
+  return entry;
 }
 
-void PatternVisitor::visitTuplePattern(swift::TuplePattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  dispatcher_.emit(TuplePatternsTrap{label});
-  auto i = 0u;
-  for (auto p : pattern->getElements()) {
-    dispatcher_.emit(TuplePatternElementsTrap{label, i++, dispatcher_.fetchLabel(p.getPattern())});
+codeql::TuplePattern PatternVisitor::translateTuplePattern(const swift::TuplePattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  for (const auto& p : pattern.getElements()) {
+    entry.elements.push_back(dispatcher_.fetchLabel(p.getPattern()));
   }
+  return entry;
 }
-void PatternVisitor::visitAnyPattern(swift::AnyPattern* pattern) {
-  dispatcher_.emit(AnyPatternsTrap{dispatcher_.assignNewLabel(pattern)});
+codeql::AnyPattern PatternVisitor::translateAnyPattern(const swift::AnyPattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  return entry;
 }
 
-void PatternVisitor::visitBindingPattern(swift::BindingPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  assert(pattern->getSubPattern() && "expect BindingPattern to have a SubPattern");
-  dispatcher_.emit(BindingPatternsTrap{label, dispatcher_.fetchLabel(pattern->getSubPattern())});
+codeql::BindingPattern PatternVisitor::translateBindingPattern(
+    const swift::BindingPattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  entry.sub_pattern = dispatcher_.fetchLabel(pattern.getSubPattern());
+  return entry;
 }
 
-void PatternVisitor::visitEnumElementPattern(swift::EnumElementPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  dispatcher_.emit(
-      EnumElementPatternsTrap{label, dispatcher_.fetchLabel(pattern->getElementDecl())});
-  if (auto subPattern = pattern->getSubPattern()) {
-    dispatcher_.emit(
-        EnumElementPatternSubPatternsTrap{label, dispatcher_.fetchLabel(pattern->getSubPattern())});
-  }
+codeql::EnumElementPattern PatternVisitor::translateEnumElementPattern(
+    const swift::EnumElementPattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  entry.element = dispatcher_.fetchLabel(pattern.getElementDecl());
+  entry.sub_pattern = dispatcher_.fetchOptionalLabel(pattern.getSubPattern());
+  return entry;
 }
 
-void PatternVisitor::visitOptionalSomePattern(swift::OptionalSomePattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  assert(pattern->getSubPattern() && "expect BindingPattern to have a SubPattern");
-  dispatcher_.emit(
-      OptionalSomePatternsTrap{label, dispatcher_.fetchLabel(pattern->getSubPattern())});
+codeql::OptionalSomePattern PatternVisitor::translateOptionalSomePattern(
+    const swift::OptionalSomePattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  entry.sub_pattern = dispatcher_.fetchLabel(pattern.getSubPattern());
+  return entry;
 }
 
-void PatternVisitor::visitIsPattern(swift::IsPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  dispatcher_.emit(IsPatternsTrap{label});
-
-  if (auto typeRepr = pattern->getCastTypeRepr()) {
-    dispatcher_.emit(IsPatternCastTypeReprsTrap{
-        label, dispatcher_.fetchLabel(typeRepr, pattern->getCastType())});
-  }
-  if (auto subPattern = pattern->getSubPattern()) {
-    dispatcher_.emit(IsPatternSubPatternsTrap{label, dispatcher_.fetchLabel(subPattern)});
-  }
+codeql::IsPattern PatternVisitor::translateIsPattern(const swift::IsPattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  entry.cast_type_repr =
+      dispatcher_.fetchOptionalLabel(pattern.getCastTypeRepr(), pattern.getCastType());
+  entry.sub_pattern = dispatcher_.fetchOptionalLabel(pattern.getSubPattern());
+  return entry;
 }
 
-void PatternVisitor::visitExprPattern(swift::ExprPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  assert(pattern->getSubExpr() && "expect ExprPattern to have SubExpr");
-  dispatcher_.emit(ExprPatternsTrap{label, dispatcher_.fetchLabel(pattern->getSubExpr())});
+codeql::ExprPattern PatternVisitor::translateExprPattern(const swift::ExprPattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  entry.sub_expr = dispatcher_.fetchLabel(pattern.getSubExpr());
+  return entry;
 }
 
-void PatternVisitor::visitParenPattern(swift::ParenPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  assert(pattern->getSubPattern() && "expect ParenPattern to have SubPattern");
-  dispatcher_.emit(ParenPatternsTrap{label, dispatcher_.fetchLabel(pattern->getSubPattern())});
+codeql::ParenPattern PatternVisitor::translateParenPattern(const swift::ParenPattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  entry.sub_pattern = dispatcher_.fetchLabel(pattern.getSubPattern());
+  return entry;
 }
 
-void PatternVisitor::visitBoolPattern(swift::BoolPattern* pattern) {
-  auto label = dispatcher_.assignNewLabel(pattern);
-  dispatcher_.emit(BoolPatternsTrap{label, pattern->getValue()});
+codeql::BoolPattern PatternVisitor::translateBoolPattern(const swift::BoolPattern& pattern) {
+  auto entry = dispatcher_.createEntry(pattern);
+  entry.value = pattern.getValue();
+  return entry;
 }
 
 }  // namespace codeql
diff --git a/swift/extractor/visitors/PatternVisitor.h b/swift/extractor/visitors/PatternVisitor.h
@@ -8,17 +8,25 @@ namespace codeql {
 class PatternVisitor : public AstVisitorBase<PatternVisitor> {
  public:
   using AstVisitorBase<PatternVisitor>::AstVisitorBase;
+  using AstVisitorBase<PatternVisitor>::visit;
 
-  void visitNamedPattern(swift::NamedPattern* pattern);
-  void visitTypedPattern(swift::TypedPattern* pattern);
-  void visitTuplePattern(swift::TuplePattern* pattern);
-  void visitAnyPattern(swift::AnyPattern* pattern);
-  void visitBindingPattern(swift::BindingPattern* pattern);
-  void visitEnumElementPattern(swift::EnumElementPattern* pattern);
-  void visitOptionalSomePattern(swift::OptionalSomePattern* pattern);
-  void visitIsPattern(swift::IsPattern* pattern);
-  void visitExprPattern(swift::ExprPattern* pattern);
-  void visitParenPattern(swift::ParenPattern* pattern);
-  void visitBoolPattern(swift::BoolPattern* pattern);
+  // 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
+  void visit(const swift::Pattern* pattern) { visit(const_cast<swift::Pattern*>(pattern)); }
+
+  codeql::NamedPattern translateNamedPattern(const swift::NamedPattern& pattern);
+  codeql::TypedPattern translateTypedPattern(const swift::TypedPattern& pattern);
+  codeql::TuplePattern translateTuplePattern(const swift::TuplePattern& pattern);
+  codeql::AnyPattern translateAnyPattern(const swift::AnyPattern& pattern);
+  codeql::BindingPattern translateBindingPattern(const swift::BindingPattern& pattern);
+  codeql::EnumElementPattern translateEnumElementPattern(const swift::EnumElementPattern& pattern);
+  codeql::OptionalSomePattern translateOptionalSomePattern(
+      const swift::OptionalSomePattern& pattern);
+  codeql::IsPattern translateIsPattern(const swift::IsPattern& pattern);
+  codeql::ExprPattern translateExprPattern(const swift::ExprPattern& pattern);
+  codeql::ParenPattern translateParenPattern(const swift::ParenPattern& pattern);
+  codeql::BoolPattern translateBoolPattern(const swift::BoolPattern& pattern);
 };
 }  // namespace codeql
diff --git a/swift/extractor/visitors/SwiftVisitor.h b/swift/extractor/visitors/SwiftVisitor.h
@@ -31,7 +31,7 @@ class SwiftVisitor : private SwiftDispatcher {
   }
   void visit(swift::CaseLabelItem* item) override { stmtVisitor.visitCaseLabelItem(item); }
   void visit(swift::Expr* expr) override { exprVisitor.visit(expr); }
-  void visit(swift::Pattern* pattern) override { patternVisitor.visit(pattern); }
+  void visit(const swift::Pattern* pattern) override { patternVisitor.visit(pattern); }
   void visit(swift::TypeBase* type) override { typeVisitor.visit(type); }
   void visit(swift::TypeRepr* typeRepr, swift::Type type) override {
     emit(typeVisitor.translateTypeRepr(*typeRepr, type));

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ class SwiftVisitor : private SwiftDispatcher {`
`31`	`31`	`}`
`32`	`32`	`void visit(swift::CaseLabelItem* item) override { stmtVisitor.visitCaseLabelItem(item); }`
`33`	`33`	`void visit(swift::Expr* expr) override { exprVisitor.visit(expr); }`
`34`		`- void visit(swift::Pattern* pattern) override { patternVisitor.visit(pattern); }`
	`34`	`+ void visit(const swift::Pattern* pattern) override { patternVisitor.visit(pattern); }`
`35`	`35`	`void visit(swift::TypeBase* type) override { typeVisitor.visit(type); }`
`36`	`36`	`void visit(swift::TypeRepr* typeRepr, swift::Type type) override {`
`37`	`37`	`emit(typeVisitor.translateTypeRepr(*typeRepr, type));`