Unified: Extract attributed types as modified_type_expr

Preserve the base type of attributed types (`inout T`, `sending T`,
`@escaping () -> T`) and keep their specifiers and attributes as modifiers.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: paldepind

unified/extractor/ast_types.yml

@@ -41,6 +41,7 @@ supertypes:
     - bulk_importing_pattern
     - ignore_pattern
     - generic_type_expr
+    - modified_type_expr
     - inferred_type_expr
   # An element of an `unresolved_operator_sequence`: either an operand (`expr`)
   # or one of the infix operators separating the operands.
@@ -553,5 +554,11 @@ named:
     base: expr
     type_argument*: expr
 
+  # A type with a modifier. In Swift this can be specifiers or attributes, such
+  # as `inout T`, `sending T` or `@escaping () -> Void`.
+  modified_type_expr:
+    modifier*: modifier
+    type: expr
+
   # A modifier such as 'static', 'public', or 'async'. For now this is just a leaf node with a string value.
   modifier:

unified/extractor/src/languages/swift/swift.rs

@@ -1164,6 +1164,24 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         // becomes a `modifier`; its source text is the modifier spelling.
         rule!((attribute) @m => (modifier #{m})),
         rule!((declModifier) @m => (modifier #{m})),
+        // Type specifiers (`inout`, `sending`, ...) are mapped to modifier.
+        rule!((simpleTypeSpecifier) @m => (modifier #{m})),
+        rule!((lifetimeTypeSpecifier) @m => (modifier #{m})),
+        rule!((nonisolatedTypeSpecifier) @m => (modifier #{m})),
+        // An attributed type is mapped to a modified type of its base type.
+        rule!(
+            (attributedType
+                specifiers: _* @specs
+                attributes: _* @attrs
+                lateSpecifiers: _* @late
+                baseType: @base)
+            =>
+            (modified_type_expr
+                modifier: {specs}
+                modifier: {attrs}
+                modifier: {late}
+                type: {base})
+        ),
         // Preserve the `super` keyword as a dedicated expression, normally used
         // as the base of a member access (`super.foo`).
         rule!((superExpr superKeyword: @@keyword) => (super_expr #{keyword})),
@@ -1471,7 +1489,6 @@ fn translation_rules() -> Vec<Rule<SwiftContext>> {
         // currently map them to the unified AST. Syntax nested inside one of
         // these roots is discarded with its parent and needs no separate rule.
         rule!((actorDecl) => (unsupported_node)),
-        rule!((attributedType) => (unsupported_node)),
         rule!((borrowExpr) => (unsupported_node)),
         rule!((classRestrictionType) => (unsupported_node)),
         rule!((compositionType) => (unsupported_node)),

unified/ql/lib/codeql/unified/internal/ExprPositions.qll

@@ -32,6 +32,8 @@ predicate isInTypeContext(Expr expr) {
   or
   expr = any(GenericTypeExpr gte).getATypeArgument()
   or
+  expr = any(ModifiedTypeExpr m).getType()
+  or
   expr.getParent() instanceof TypeConstraint
   or
   exists(Identifier id | id = NameBinding::getStaticBindingTargetFromRef(expr) |