Merge pull request #9639 from github/redsun82/swift-extraction

Swift: some expression extractions

Author: redsun82

Diff for: swift/codegen/schema.yml

@@ -385,6 +385,7 @@ EnumIsCaseExpr:
 
 ErrorExpr:
   _extends: Expr
+  _tags: [ no_qltest ]  # unexpected emission
 
 ExplicitCastExpr:
   _extends: Expr
@@ -445,7 +446,7 @@ LookupExpr:
   _extends: Expr
   _children:
     base_expr: Expr
-  member: Decl
+  member: Decl?
 
 MakeTemporarilyEscapableExpr:
   _extends: Expr
@@ -459,6 +460,7 @@ ObjCSelectorExpr:
   _children:
     sub_expr: Expr
   method: AbstractFunctionDecl
+  _tags: [ no_qltest ]  # to be tested in integration tests
 
 OneWayExpr:
   _extends: Expr
@@ -498,6 +500,9 @@ RebindSelfInConstructorExpr:
 
 SequenceExpr:
   _extends: Expr
+  _children:
+    elements: Expr*
+  _tags: [ no_qltest ]  # we should really never extract these, as these should be resolved to trees of operations
 
 SuperRefExpr:
   _extends: Expr
@@ -528,18 +533,27 @@ TypeExpr:
 
 UnresolvedDeclRefExpr:
   _extends: Expr
+  name: string?
+  _tags: [ no_qltest ]  # we should really never extract these
 
 UnresolvedDotExpr:
   _extends: Expr
+  _children:
+    base: Expr
+  name: string
 
 UnresolvedMemberExpr:
   _extends: Expr
+  name: string
+  _tags: [ no_qltest ]  # we should really never extract these
 
 UnresolvedPatternExpr:
   _extends: Expr
+  _tags: [ no_qltest ]  # we should really never extract these
 
 UnresolvedSpecializeExpr:
   _extends: Expr
+  _tags: [ no_qltest ]  # we should really never extract these
 
 VarargExpansionExpr:
   _extends: Expr
@@ -807,9 +821,11 @@ ArrayToPointerExpr:
 
 BridgeFromObjCExpr:
   _extends: ImplicitConversionExpr
+  _tags: [ no_qltest ]  # to be tested in integration tests
 
 BridgeToObjCExpr:
   _extends: ImplicitConversionExpr
+  _tags: [ no_qltest ]  # to be tested in integration tests
 
 ClassMetatypeToObjectExpr:
   _extends: ImplicitConversionExpr
@@ -819,6 +835,7 @@ CollectionUpcastConversionExpr:
 
 ConditionalBridgeFromObjCExpr:
   _extends: ImplicitConversionExpr
+  _tags: [ no_qltest ]  # to be tested in integration tests
 
 CovariantFunctionConversionExpr:
   _extends: ImplicitConversionExpr

Diff for: swift/extractor/SwiftDispatcher.h

@@ -64,6 +64,7 @@ class SwiftDispatcher {
   // visitor (see `visit(T *)` methods below).
   template <typename E>
   TrapLabelOf<E> fetchLabel(E* e) {
+    assert(e && "trying to fetch a label on nullptr, maybe fetchOptionalLabel is to be used?");
     // this is required so we avoid any recursive loop: a `fetchLabel` during the visit of `e` might
     // end up calling `fetchLabel` on `e` itself, so we want the visit of `e` to call `fetchLabel`
     // only after having called `assignNewLabel` on `e`.

Diff for: swift/extractor/visitors/ExprVisitor.h

@@ -271,19 +271,16 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
     emitImplicitConversionExpr(expr, label);
   }
 
-  void visitTypeExpr(swift::TypeExpr* expr) {
-    auto label = dispatcher_.assignNewLabel(expr);
-    dispatcher_.emit(TypeExprsTrap{label});
-    if (auto repr = expr->getTypeRepr()) {
-      auto typeLabel = dispatcher_.fetchLabel(repr);
-      dispatcher_.emit(TypeExprTypeReprsTrap{label, typeLabel});
-    }
+  codeql::TypeExpr translateTypeExpr(const swift::TypeExpr& expr) {
+    TypeExpr entry{dispatcher_.assignNewLabel(expr)};
+    entry.type_repr = dispatcher_.fetchOptionalLabel(expr.getTypeRepr());
+    return entry;
   }
 
-  void visitParenExpr(swift::ParenExpr* expr) {
-    auto label = dispatcher_.assignNewLabel(expr);
-    dispatcher_.emit(ParenExprsTrap{label});
-    emitIdentityExpr(expr, label);
+  codeql::ParenExpr translateParenExpr(const swift::ParenExpr& expr) {
+    ParenExpr entry{dispatcher_.assignNewLabel(expr)};
+    fillIdentityExpr(expr, entry);
+    return entry;
   }
 
   void visitLoadExpr(swift::LoadExpr* expr) {
@@ -531,6 +528,62 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
     dispatcher_.emit(OtherConstructorDeclRefExprsTrap{label, ctorLabel});
   }
 
+  codeql::UnresolvedDeclRefExpr translateUnresolvedDeclRefExpr(
+      const swift::UnresolvedDeclRefExpr& expr) {
+    codeql::UnresolvedDeclRefExpr entry{dispatcher_.assignNewLabel(expr)};
+    if (expr.hasName()) {
+      llvm::SmallVector<char> scratch;
+      entry.name = expr.getName().getString(scratch).str();
+    }
+    return entry;
+  }
+
+  codeql::UnresolvedDotExpr translateUnresolvedDotExpr(const swift::UnresolvedDotExpr& expr) {
+    codeql::UnresolvedDotExpr entry{dispatcher_.assignNewLabel(expr)};
+    assert(expr.getBase() && "Expect UnresolvedDotExpr to have a base");
+    entry.base = dispatcher_.fetchLabel(expr.getBase());
+    llvm::SmallVector<char> scratch;
+    entry.name = expr.getName().getString(scratch).str();
+    return entry;
+  }
+
+  codeql::UnresolvedMemberExpr translateUnresolvedMemberExpr(
+      const swift::UnresolvedMemberExpr& expr) {
+    UnresolvedMemberExpr entry{dispatcher_.assignNewLabel(expr)};
+    llvm::SmallVector<char> scratch;
+    entry.name = expr.getName().getString(scratch).str();
+    return entry;
+  }
+
+  codeql::SequenceExpr translateSequenceExpr(const swift::SequenceExpr& expr) {
+    SequenceExpr entry{dispatcher_.assignNewLabel(expr)};
+    entry.elements = dispatcher_.fetchRepeatedLabels(expr.getElements());
+    return entry;
+  }
+
+  codeql::BridgeToObjCExpr translateBridgeToObjCExpr(const swift::BridgeToObjCExpr& expr) {
+    BridgeToObjCExpr entry{dispatcher_.assignNewLabel(expr)};
+    entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
+    return entry;
+  }
+
+  codeql::BridgeFromObjCExpr translateBridgeFromObjCExpr(const swift::BridgeFromObjCExpr& expr) {
+    BridgeFromObjCExpr entry{dispatcher_.assignNewLabel(expr)};
+    entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
+    return entry;
+  }
+
+  codeql::DotSelfExpr translateDotSelfExpr(const swift::DotSelfExpr& expr) {
+    DotSelfExpr entry{dispatcher_.assignNewLabel(expr)};
+    fillIdentityExpr(expr, entry);
+    return entry;
+  }
+
+  codeql::ErrorExpr translateErrorExpr(const swift::ErrorExpr& expr) {
+    ErrorExpr entry{dispatcher_.assignNewLabel(expr)};
+    return entry;
+  }
+
  private:
   void fillAbstractClosureExpr(const swift::AbstractClosureExpr& expr,
                                codeql::AbstractClosureExpr& entry) {
@@ -560,9 +613,9 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
     dispatcher_.emit(ExplicitCastExprsTrap{label, dispatcher_.fetchLabel(expr->getSubExpr())});
   }
 
-  void emitIdentityExpr(swift::IdentityExpr* expr, TrapLabel<IdentityExprTag> label) {
-    assert(expr->getSubExpr() && "IdentityExpr has getSubExpr()");
-    dispatcher_.emit(IdentityExprsTrap{label, dispatcher_.fetchLabel(expr->getSubExpr())});
+  void fillIdentityExpr(const swift::IdentityExpr& expr, codeql::IdentityExpr& entry) {
+    assert(expr.getSubExpr() && "IdentityExpr has getSubExpr()");
+    entry.sub_expr = dispatcher_.fetchLabel(expr.getSubExpr());
   }
 
   void emitAnyTryExpr(swift::AnyTryExpr* expr, TrapLabel<AnyTryExprTag> label) {
@@ -590,9 +643,11 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
   void emitLookupExpr(const swift::LookupExpr* expr, TrapLabel<LookupExprTag> label) {
     assert(expr->getBase() && "LookupExpr has getBase()");
     auto baseLabel = dispatcher_.fetchLabel(expr->getBase());
-    assert(expr->hasDecl() && "LookupExpr has decl");
-    auto declLabel = dispatcher_.fetchLabel(expr->getDecl().getDecl());
-    dispatcher_.emit(LookupExprsTrap{label, baseLabel, declLabel});
+    dispatcher_.emit(LookupExprsTrap{label, baseLabel});
+    if (expr->hasDecl()) {
+      auto declLabel = dispatcher_.fetchLabel(expr->getDecl().getDecl());
+      dispatcher_.emit(LookupExprMembersTrap{label, declLabel});
+    }
   }
 
   /*

Diff for: swift/ql/lib/codeql/swift/elements/expr/UnresolvedDotExpr.qll

@@ -1,4 +1,5 @@
-// generated by codegen/codegen.py, remove this comment if you wish to edit this file
 private import codeql.swift.generated.expr.UnresolvedDotExpr
 
-class UnresolvedDotExpr extends UnresolvedDotExprBase { }
+class UnresolvedDotExpr extends UnresolvedDotExprBase {
+  override string toString() { result = "... ." + getName() }
+}

Diff for: swift/ql/lib/codeql/swift/generated/GetImmediateParent.qll

@@ -102,7 +102,7 @@ Element getAnImmediateChild(Element e) {
       or
       lazy_initializer_exprs(e, x)
       or
-      lookup_exprs(e, x, _)
+      lookup_exprs(e, x)
       or
       make_temporarily_escapable_exprs(e, x, _, _)
       or
@@ -128,6 +128,8 @@ Element getAnImmediateChild(Element e) {
       or
       self_apply_exprs(e, x)
       or
+      sequence_expr_elements(e, _, x)
+      or
       subscript_expr_arguments(e, _, x)
       or
       tap_expr_sub_exprs(e, x)
@@ -140,6 +142,8 @@ Element getAnImmediateChild(Element e) {
       or
       type_expr_type_reprs(e, x)
       or
+      unresolved_dot_exprs(e, x, _)
+      or
       vararg_expansion_exprs(e, x)
       or
       binding_patterns(e, x)

Diff for: swift/ql/lib/codeql/swift/generated/expr/LookupExpr.qll

@@ -5,15 +5,17 @@ import codeql.swift.elements.expr.Expr
 class LookupExprBase extends @lookup_expr, Expr {
   Expr getBaseExpr() {
     exists(Expr x |
-      lookup_exprs(this, x, _) and
+      lookup_exprs(this, x) and
       result = x.resolve()
     )
   }
 
   Decl getMember() {
     exists(Decl x |
-      lookup_exprs(this, _, x) and
+      lookup_expr_members(this, x) and
       result = x.resolve()
     )
   }
+
+  predicate hasMember() { exists(getMember()) }
 }

Diff for: swift/ql/lib/codeql/swift/generated/expr/SequenceExpr.qll

@@ -3,4 +3,15 @@ import codeql.swift.elements.expr.Expr
 
 class SequenceExprBase extends @sequence_expr, Expr {
   override string getAPrimaryQlClass() { result = "SequenceExpr" }
+
+  Expr getElement(int index) {
+    exists(Expr x |
+      sequence_expr_elements(this, index, x) and
+      result = x.resolve()
+    )
+  }
+
+  Expr getAnElement() { result = getElement(_) }
+
+  int getNumberOfElements() { result = count(getAnElement()) }
 }

Diff for: swift/ql/lib/codeql/swift/generated/expr/UnresolvedDeclRefExpr.qll

@@ -3,4 +3,8 @@ import codeql.swift.elements.expr.Expr
 
 class UnresolvedDeclRefExprBase extends @unresolved_decl_ref_expr, Expr {
   override string getAPrimaryQlClass() { result = "UnresolvedDeclRefExpr" }
+
+  string getName() { unresolved_decl_ref_expr_names(this, result) }
+
+  predicate hasName() { exists(getName()) }
 }

Diff for: swift/ql/lib/codeql/swift/generated/expr/UnresolvedDotExpr.qll

@@ -3,4 +3,13 @@ import codeql.swift.elements.expr.Expr
 
 class UnresolvedDotExprBase extends @unresolved_dot_expr, Expr {
   override string getAPrimaryQlClass() { result = "UnresolvedDotExpr" }
+
+  Expr getBase() {
+    exists(Expr x |
+      unresolved_dot_exprs(this, x, _) and
+      result = x.resolve()
+    )
+  }
+
+  string getName() { unresolved_dot_exprs(this, _, result) }
 }

Diff for: swift/ql/lib/codeql/swift/generated/expr/UnresolvedMemberExpr.qll

@@ -3,4 +3,6 @@ import codeql.swift.elements.expr.Expr
 
 class UnresolvedMemberExprBase extends @unresolved_member_expr, Expr {
   override string getAPrimaryQlClass() { result = "UnresolvedMemberExpr" }
+
+  string getName() { unresolved_member_exprs(this, result) }
 }

Diff for: swift/ql/lib/swift.dbscheme

@@ -955,7 +955,12 @@ lazy_initializer_exprs(
 #keyset[id]
 lookup_exprs(
   int id: @lookup_expr ref,
-  int base_expr: @expr ref,
+  int base_expr: @expr ref
+);
+
+#keyset[id]
+lookup_expr_members(
+  int id: @lookup_expr ref,
   int member: @decl ref
 );
 
@@ -1016,6 +1021,13 @@ sequence_exprs(
   unique int id: @sequence_expr
 );
 
+#keyset[id, index]
+sequence_expr_elements(
+  int id: @sequence_expr ref,
+  int index: int ref,
+  int element: @expr ref
+);
+
 super_ref_exprs(
   unique int id: @super_ref_expr,
   int self: @var_decl ref
@@ -1064,12 +1076,21 @@ unresolved_decl_ref_exprs(
   unique int id: @unresolved_decl_ref_expr
 );
 
+#keyset[id]
+unresolved_decl_ref_expr_names(
+  int id: @unresolved_decl_ref_expr ref,
+  string name: string ref
+);
+
 unresolved_dot_exprs(
-  unique int id: @unresolved_dot_expr
+  unique int id: @unresolved_dot_expr,
+  int base: @expr ref,
+  string name: string ref
 );
 
 unresolved_member_exprs(
-  unique int id: @unresolved_member_expr
+  unique int id: @unresolved_member_expr,
+  string name: string ref
 );
 
 unresolved_pattern_exprs(