Merge pull request #9274 from MathiasVP/swift-extract-semantics-and-accessor-kinds

Swift: Extract semantics and accessor kinds

Author: MathiasVP

swift/codegen/schema.yml

@@ -327,6 +327,9 @@ DeclRefExpr:
   _extends: Expr
   decl: Decl
   replacement_types: Type*
+  has_direct_to_storage_semantics: predicate
+  has_direct_to_implementation_semantics: predicate
+  has_ordinary_semantics: predicate
 
 DefaultArgumentExpr:
   _extends: Expr
@@ -404,6 +407,8 @@ LiteralExpr:
 
 LookupExpr:
   _extends: Expr
+  base_expr: Expr
+  member: Decl
 
 MakeTemporarilyEscapableExpr:
   _extends: Expr
@@ -653,6 +658,7 @@ AbstractFunctionDecl:
 
 AbstractStorageDecl:
   _extends: ValueDecl
+  accessor_decls: AccessorDecl*
 
 EnumElementDecl:
   _extends: ValueDecl
@@ -840,14 +846,17 @@ DynamicLookupExpr:
 
 MemberRefExpr:
   _extends: LookupExpr
-  base_expr: Expr
+  has_direct_to_storage_semantics: predicate
+  has_direct_to_implementation_semantics: predicate
+  has_ordinary_semantics: predicate
 
 SubscriptExpr:
   _extends:
-    - GenericContext
     - LookupExpr
-  base_expr: Expr
   arguments: Argument*
+  has_direct_to_storage_semantics: predicate
+  has_direct_to_implementation_semantics: predicate
+  has_ordinary_semantics: predicate
 
 OverloadedDeclRefExpr:
   _extends: OverloadSetRefExpr
@@ -927,7 +936,11 @@ FuncDecl:
   _extends: AbstractFunctionDecl
 
 SubscriptDecl:
-  _extends: AbstractStorageDecl
+  _extends:
+    - AbstractStorageDecl
+    - GenericContext
+  params: ParamDecl*
+  element_type: Type
 
 VarDecl:
   _extends: AbstractStorageDecl
@@ -1002,6 +1015,10 @@ WhileStmt:
 
 AccessorDecl:
   _extends: FuncDecl
+  is_getter: predicate
+  is_setter: predicate
+  is_will_set: predicate
+  is_did_set: predicate
 
 ConcreteFuncDecl:
   _extends: FuncDecl

swift/extractor/visitors/DeclVisitor.h

@@ -157,6 +157,39 @@ class DeclVisitor : public AstVisitorBase<DeclVisitor> {
     emitTypeDecl(decl, label);
   }
 
+  void visitAccessorDecl(swift::AccessorDecl* decl) {
+    auto label = dispatcher_.assignNewLabel(decl);
+    dispatcher_.emit(AccessorDeclsTrap{label});
+    switch (decl->getAccessorKind()) {
+      case swift::AccessorKind::Get:
+        dispatcher_.emit(AccessorDeclIsGetterTrap{label});
+        break;
+      case swift::AccessorKind::Set:
+        dispatcher_.emit(AccessorDeclIsSetterTrap{label});
+        break;
+      case swift::AccessorKind::WillSet:
+        dispatcher_.emit(AccessorDeclIsWillSetTrap{label});
+        break;
+      case swift::AccessorKind::DidSet:
+        dispatcher_.emit(AccessorDeclIsDidSetTrap{label});
+        break;
+    }
+    emitAccessorDecl(decl, label);
+  }
+
+  void visitSubscriptDecl(swift::SubscriptDecl* decl) {
+    auto label = dispatcher_.assignNewLabel(decl);
+    auto elementTypeLabel = dispatcher_.fetchLabel(decl->getElementInterfaceType());
+    dispatcher_.emit(SubscriptDeclsTrap{label, elementTypeLabel});
+    if (auto indices = decl->getIndices()) {
+      for (auto i = 0u; i < indices->size(); ++i) {
+        dispatcher_.emit(
+            SubscriptDeclParamsTrap{label, i, dispatcher_.fetchLabel(indices->get(i))});
+      }
+    }
+    emitAbstractStorageDecl(decl, label);
+  }
+
  private:
   void emitConstructorDecl(swift::ConstructorDecl* decl, TrapLabel<ConstructorDeclTag> label) {
     emitAbstractFunctionDecl(decl, label);
@@ -168,9 +201,9 @@ class DeclVisitor : public AstVisitorBase<DeclVisitor> {
 
   void emitAbstractFunctionDecl(swift::AbstractFunctionDecl* decl,
                                 TrapLabel<AbstractFunctionDeclTag> label) {
-    assert(decl->hasName() && "Expect functions to have name");
     assert(decl->hasParameterList() && "Expect functions to have a parameter list");
-    auto name = decl->getName().isSpecial() ? "(unnamed function decl)" : decl->getNameStr().str();
+    auto name = !decl->hasName() || decl->getName().isSpecial() ? "(unnamed function decl)"
+                                                                : decl->getNameStr().str();
     dispatcher_.emit(AbstractFunctionDeclsTrap{label, name});
     if (auto body = decl->getBody()) {
       dispatcher_.emit(AbstractFunctionDeclBodiesTrap{label, dispatcher_.fetchLabel(body)});
@@ -226,7 +259,7 @@ class DeclVisitor : public AstVisitorBase<DeclVisitor> {
             VarDeclAttachedPropertyWrapperTypesTrap{label, dispatcher_.fetchLabel(propertyType)});
       }
     }
-    emitValueDecl(decl, label);
+    emitAbstractStorageDecl(decl, label);
   }
 
   void emitNominalTypeDecl(swift::NominalTypeDecl* decl, TrapLabel<NominalTypeDeclTag> label) {
@@ -251,6 +284,20 @@ class DeclVisitor : public AstVisitorBase<DeclVisitor> {
     assert(decl->getInterfaceType() && "Expect ValueDecl to have InterfaceType");
     dispatcher_.emit(ValueDeclsTrap{label, dispatcher_.fetchLabel(decl->getInterfaceType())});
   }
+
+  void emitAccessorDecl(swift::AccessorDecl* decl, TrapLabel<AccessorDeclTag> label) {
+    emitAbstractFunctionDecl(decl, label);
+  }
+
+  void emitAbstractStorageDecl(const swift::AbstractStorageDecl* decl,
+                               TrapLabel<AbstractStorageDeclTag> label) {
+    auto i = 0u;
+    for (auto acc : decl->getAllAccessors()) {
+      dispatcher_.emit(
+          AbstractStorageDeclAccessorDeclsTrap{label, i++, dispatcher_.fetchLabel(acc)});
+    }
+    emitValueDecl(decl, label);
+  }
 };
 
 }  // namespace codeql

swift/extractor/visitors/ExprVisitor.h

@@ -85,6 +85,9 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
   void visitDeclRefExpr(swift::DeclRefExpr* expr) {
     auto label = dispatcher_.assignNewLabel(expr);
     dispatcher_.emit(DeclRefExprsTrap{label, dispatcher_.fetchLabel(expr->getDecl())});
+    emitAccessorSemantics<DeclRefExprHasDirectToStorageSemanticsTrap,
+                          DeclRefExprHasDirectToImplementationSemanticsTrap,
+                          DeclRefExprHasOrdinarySemanticsTrap>(expr, label);
     auto i = 0u;
     for (auto t : expr->getDeclRef().getSubstitutions().getReplacementTypes()) {
       dispatcher_.emit(DeclRefExprReplacementTypesTrap{label, i++, dispatcher_.fetchLabel(t)});
@@ -398,16 +401,24 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
     emitExplicitCastExpr(expr, label);
   }
 
+  void visitLookupExpr(swift::LookupExpr* expr) {
+    auto label = dispatcher_.assignNewLabel(expr);
+    emitLookupExpr(expr, label);
+  }
+
   void visitSubscriptExpr(swift::SubscriptExpr* expr) {
     auto label = dispatcher_.assignNewLabel(expr);
-    assert(expr->getBase() && "SubscriptExpr has getBase()");
-    auto baseLabel = dispatcher_.fetchLabel(expr->getBase());
-    dispatcher_.emit(SubscriptExprsTrap{label, baseLabel});
+    dispatcher_.emit(SubscriptExprsTrap{label});
+
+    emitAccessorSemantics<SubscriptExprHasDirectToStorageSemanticsTrap,
+                          SubscriptExprHasDirectToImplementationSemanticsTrap,
+                          SubscriptExprHasOrdinarySemanticsTrap>(expr, label);
 
     auto i = 0u;
     for (const auto& arg : *expr->getArgs()) {
       dispatcher_.emit(SubscriptExprArgumentsTrap{label, i++, emitArgument(arg)});
     }
+    emitLookupExpr(expr, label);
   }
 
   void visitDictionaryExpr(swift::DictionaryExpr* expr) {
@@ -434,10 +445,13 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
 
   void visitMemberRefExpr(swift::MemberRefExpr* expr) {
     auto label = dispatcher_.assignNewLabel(expr);
-    assert(expr->getBase() && "MemberRefExpr has getBase()");
+    dispatcher_.emit(MemberRefExprsTrap{label});
 
-    auto baseLabel = dispatcher_.fetchLabel(expr->getBase());
-    dispatcher_.emit(MemberRefExprsTrap{label, baseLabel});
+    emitAccessorSemantics<MemberRefExprHasDirectToStorageSemanticsTrap,
+                          MemberRefExprHasDirectToImplementationSemanticsTrap,
+                          MemberRefExprHasOrdinarySemanticsTrap>(expr, label);
+
+    emitLookupExpr(expr, label);
   }
 
   void visitDerivedToBaseExpr(swift::DerivedToBaseExpr* expr) {
@@ -542,6 +556,38 @@ class ExprVisitor : public AstVisitorBase<ExprVisitor> {
     dispatcher_.emit(SelfApplyExprsTrap{label, baseLabel});
     emitApplyExpr(expr, label);
   }
+
+  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});
+  }
+
+  /*
+   * `DirectToStorage`, `DirectToImplementation`, and `DirectToImplementation` must be
+   * constructable from a `Label` argument, and values of `T` must have a
+   * `getAccessSemantics` member that returns a `swift::AccessSemantics`.
+   */
+  template <typename DirectToStorage,
+            typename DirectToImplementation,
+            typename Ordinary,
+            typename T,
+            typename Label>
+  void emitAccessorSemantics(T* ast, Label label) {
+    switch (ast->getAccessSemantics()) {
+      case swift::AccessSemantics::DirectToStorage:
+        dispatcher_.emit(DirectToStorage{label});
+        break;
+      case swift::AccessSemantics::DirectToImplementation:
+        dispatcher_.emit(DirectToImplementation{label});
+        break;
+      case swift::AccessSemantics::Ordinary:
+        dispatcher_.emit(Ordinary{label});
+        break;
+    }
+  }
 };
 
 }  // namespace codeql

swift/ql/lib/codeql/swift/generated/decl/AbstractStorageDecl.qll

@@ -1,4 +1,16 @@
 // generated by codegen/codegen.py
+import codeql.swift.elements.decl.AccessorDecl
 import codeql.swift.elements.decl.ValueDecl
 
-class AbstractStorageDeclBase extends @abstract_storage_decl, ValueDecl { }
+class AbstractStorageDeclBase extends @abstract_storage_decl, ValueDecl {
+  AccessorDecl getAccessorDecl(int index) {
+    exists(AccessorDecl x |
+      abstract_storage_decl_accessor_decls(this, index, x) and
+      result = x.resolve()
+    )
+  }
+
+  AccessorDecl getAnAccessorDecl() { result = getAccessorDecl(_) }
+
+  int getNumberOfAccessorDecls() { result = count(getAnAccessorDecl()) }
+}

swift/ql/lib/codeql/swift/generated/decl/AccessorDecl.qll

@@ -3,4 +3,12 @@ import codeql.swift.elements.decl.FuncDecl
 
 class AccessorDeclBase extends @accessor_decl, FuncDecl {
   override string getAPrimaryQlClass() { result = "AccessorDecl" }
+
+  predicate isGetter() { accessor_decl_is_getter(this) }
+
+  predicate isSetter() { accessor_decl_is_setter(this) }
+
+  predicate isWillSet() { accessor_decl_is_will_set(this) }
+
+  predicate isDidSet() { accessor_decl_is_did_set(this) }
 }

swift/ql/lib/codeql/swift/generated/decl/SubscriptDecl.qll

@@ -1,6 +1,27 @@
 // generated by codegen/codegen.py
 import codeql.swift.elements.decl.AbstractStorageDecl
+import codeql.swift.elements.decl.GenericContext
+import codeql.swift.elements.decl.ParamDecl
+import codeql.swift.elements.type.Type
 
-class SubscriptDeclBase extends @subscript_decl, AbstractStorageDecl {
+class SubscriptDeclBase extends @subscript_decl, AbstractStorageDecl, GenericContext {
   override string getAPrimaryQlClass() { result = "SubscriptDecl" }
+
+  ParamDecl getParam(int index) {
+    exists(ParamDecl x |
+      subscript_decl_params(this, index, x) and
+      result = x.resolve()
+    )
+  }
+
+  ParamDecl getAParam() { result = getParam(_) }
+
+  int getNumberOfParams() { result = count(getAParam()) }
+
+  Type getElementType() {
+    exists(Type x |
+      subscript_decls(this, x) and
+      result = x.resolve()
+    )
+  }
 }

swift/ql/lib/codeql/swift/generated/expr/DeclRefExpr.qll

@@ -23,4 +23,12 @@ class DeclRefExprBase extends @decl_ref_expr, Expr {
   Type getAReplacementType() { result = getReplacementType(_) }
 
   int getNumberOfReplacementTypes() { result = count(getAReplacementType()) }
+
+  predicate hasDirectToStorageSemantics() { decl_ref_expr_has_direct_to_storage_semantics(this) }
+
+  predicate hasDirectToImplementationSemantics() {
+    decl_ref_expr_has_direct_to_implementation_semantics(this)
+  }
+
+  predicate hasOrdinarySemantics() { decl_ref_expr_has_ordinary_semantics(this) }
 }

swift/ql/lib/codeql/swift/generated/expr/LookupExpr.qll

@@ -1,4 +1,19 @@
 // generated by codegen/codegen.py
+import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.expr.Expr
 
-class LookupExprBase extends @lookup_expr, Expr { }
+class LookupExprBase extends @lookup_expr, Expr {
+  Expr getBaseExpr() {
+    exists(Expr x |
+      lookup_exprs(this, x, _) and
+      result = x.resolve()
+    )
+  }
+
+  Decl getMember() {
+    exists(Decl x |
+      lookup_exprs(this, _, x) and
+      result = x.resolve()
+    )
+  }
+}

swift/ql/lib/codeql/swift/generated/expr/MemberRefExpr.qll

@@ -1,14 +1,14 @@
 // generated by codegen/codegen.py
-import codeql.swift.elements.expr.Expr
 import codeql.swift.elements.expr.LookupExpr
 
 class MemberRefExprBase extends @member_ref_expr, LookupExpr {
   override string getAPrimaryQlClass() { result = "MemberRefExpr" }
 
-  Expr getBaseExpr() {
-    exists(Expr x |
-      member_ref_exprs(this, x) and
-      result = x.resolve()
-    )
+  predicate hasDirectToStorageSemantics() { member_ref_expr_has_direct_to_storage_semantics(this) }
+
+  predicate hasDirectToImplementationSemantics() {
+    member_ref_expr_has_direct_to_implementation_semantics(this)
   }
+
+  predicate hasOrdinarySemantics() { member_ref_expr_has_ordinary_semantics(this) }
 }

swift/ql/lib/codeql/swift/generated/expr/SubscriptExpr.qll

@@ -1,19 +1,10 @@
 // generated by codegen/codegen.py
 import codeql.swift.elements.expr.Argument
-import codeql.swift.elements.expr.Expr
-import codeql.swift.elements.decl.GenericContext
 import codeql.swift.elements.expr.LookupExpr
 
-class SubscriptExprBase extends @subscript_expr, GenericContext, LookupExpr {
+class SubscriptExprBase extends @subscript_expr, LookupExpr {
   override string getAPrimaryQlClass() { result = "SubscriptExpr" }
 
-  Expr getBaseExpr() {
-    exists(Expr x |
-      subscript_exprs(this, x) and
-      result = x.resolve()
-    )
-  }
-
   Argument getArgument(int index) {
     exists(Argument x |
       subscript_expr_arguments(this, index, x) and
@@ -24,4 +15,12 @@ class SubscriptExprBase extends @subscript_expr, GenericContext, LookupExpr {
   Argument getAnArgument() { result = getArgument(_) }
 
   int getNumberOfArguments() { result = count(getAnArgument()) }
+
+  predicate hasDirectToStorageSemantics() { subscript_expr_has_direct_to_storage_semantics(this) }
+
+  predicate hasDirectToImplementationSemantics() {
+    subscript_expr_has_direct_to_implementation_semantics(this)
+  }
+
+  predicate hasOrdinarySemantics() { subscript_expr_has_ordinary_semantics(this) }
 }