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

Rust: introduce typed labels

Browse Source
This commit is contained in:
Paolo Tranquilli
2024-09-13 13:18:33 +02:00
parent 0b850a2dff
commit faf1eeeb0d
18 changed files with 4922 additions and 966 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
misc/codegen/generators/rustgen.py
View File

@@ -20,7 +20,7 @@ def _get_type(t: str) -> str:
case "int":
return "usize"
case _ if t[0].isupper():
return "trap::Label"
return f"{t}TrapLabel"
case "boolean":
assert False, "boolean unsupported"
case _:
@@ -57,6 +57,15 @@ def _get_properties(
yield cls, p
def _get_ancestors(
cls: schema.Class, lookup: dict[str, schema.Class]
) -> typing.Iterable[schema.Class]:
for b in cls.bases:
base = lookup[b]
yield base
yield from _get_ancestors(base, lookup)
class Processor:
def __init__(self, data: schema.Schema):
self._classmap = data.classes
@@ -69,14 +78,15 @@ class Processor:
_get_field(c, p)
for c, p in _get_properties(cls, self._classmap)
if "rust_skip" not in p.pragmas and not p.synth
],
] if not cls.derived else [],
ancestors=sorted(set(a.name for a in _get_ancestors(cls, self._classmap))),
table_name=inflection.tableize(cls.name),
)
def get_classes(self):
ret = {"": []}
for k, cls in self._classmap.items():
if not cls.synth and not cls.derived:
if not cls.synth:
ret.setdefault(cls.group, []).append(self._get_class(cls.name))
return ret

3
misc/codegen/lib/rust.py
View File

@@ -110,8 +110,9 @@ class Field:
@dataclasses.dataclass
class Class:
name: str
table_name: str
table_name: str | None = None
fields: list[Field] = dataclasses.field(default_factory=list)
ancestors: list[str] = dataclasses.field(default_factory=list)
@property
def single_field_entries(self):

75
misc/codegen/templates/rust_classes.mustache
View File

@@ -2,48 +2,77 @@
#![cfg_attr(any(), rustfmt::skip)]
use crate::trap::{TrapId, TrapEntry};
use codeql_extractor::trap;
use crate::trap;
{{#classes}}
#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct {{name}}TrapLabel(trap::UntypedLabel);
impl From<trap::UntypedLabel> for {{name}}TrapLabel {
fn from(value: trap::UntypedLabel) -> Self {
Self(value)
}
}
impl From<{{name}}TrapLabel> for trap::TrapId<{{name}}> {
fn from(value: {{name}}TrapLabel) -> Self {
Self::Label(value)
}
}
impl trap::Label for {{name}}TrapLabel {
fn as_untyped(&self) -> trap::UntypedLabel {
self.0
}
}
impl From<{{name}}TrapLabel> for trap::Arg {
fn from(value: {{name}}TrapLabel) -> Self {
value.0.into()
}
}
{{#table_name}}
#[derive(Debug)]
pub struct {{name}} {
pub id: TrapId,
pub id: trap::TrapId<{{name}}>,
{{#fields}}
pub {{field_name}}: {{type}},
{{/fields}}
}
impl TrapEntry for {{name}} {
fn extract_id(&mut self) -> TrapId {
std::mem::replace(&mut self.id, TrapId::Star)
impl trap::TrapEntry for {{name}} {
fn class_name() -> &'static str { "{{name}}" }
fn extract_id(&mut self) -> trap::TrapId<Self> {
std::mem::replace(&mut self.id, trap::TrapId::Star)
}
fn emit(self, id: trap::Label, out: &mut trap::Writer) {
fn emit(self, id: Self::Label, out: &mut trap::Writer) {
{{#single_field_entries}}
out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{#fields}}, self.{{field_name}}.into(){{/fields}}]);
out.add_tuple("{{table_name}}", vec![id.into(){{#fields}}, self.{{field_name}}.into(){{/fields}}]);
{{/single_field_entries}}
{{#fields}}
{{#is_predicate}}
if self.{{field_name}} {
out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id)]);
out.add_tuple("{{table_name}}", vec![id.into()]);
}
{{/is_predicate}}
{{#is_optional}}
{{^is_repeated}}
if let Some(v) = self.{{field_name}} {
out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id), v.into()]);
out.add_tuple("{{table_name}}", vec![id.into(), v.into()]);
}
{{/is_repeated}}
{{/is_optional}}
{{#is_repeated}}
for (i, v) in self.{{field_name}}.into_iter().enumerate() {
{{^is_optional}}
out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
out.add_tuple("{{table_name}}", vec![id.into(){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
{{/is_optional}}
{{#is_optional}}
if let Some(v) = v {
out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
out.add_tuple("{{table_name}}", vec![id.into(){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
}
{{/is_optional}}
}
@@ -51,4 +80,26 @@ impl TrapEntry for {{name}} {
{{/fields}}
}
}
{{/table_name}}
{{^table_name}}
{{! virtual class, make it unbuildable }}
pub struct {{name}} {
unused: ()
}
{{/table_name}}
impl trap::TrapClass for {{name}} {
type Label = {{name}}TrapLabel;
}
{{/classes}}
// Conversions
{{#classes}}
{{#ancestors}}
impl From<{{name}}TrapLabel> for {{.}}TrapLabel {
fn from(value: {{name}}TrapLabel) -> Self {
value.0.into()
}
}
{{/ancestors}}
{{/classes}}

2
rust/extractor/src/generated/.generated.list generated
View File

@@ -1,2 +1,2 @@
mod.rs 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e
top.rs 7150acaeab0b57039ca9f2ed20311229aab5fd48b533f13410ecc34fd8e3bda0 7150acaeab0b57039ca9f2ed20311229aab5fd48b533f13410ecc34fd8e3bda0
top.rs e06dc90de4abd57719786fd5e49e6ea3089ec3ec167c64446e25d95a16b1714c e06dc90de4abd57719786fd5e49e6ea3089ec3ec167c64446e25d95a16b1714c

4820
rust/extractor/src/generated/top.rs generated
View File

File diff suppressed because it is too large Load Diff

351
rust/extractor/src/translate.rs
View File

@@ -1,5 +1,5 @@
use crate::archive::Archiver;
use crate::trap::{AsTrapKeyPart, TrapFile, TrapId};
use crate::trap::{AsTrapKeyPart, Label, TrapFile, TrapId};
use crate::{generated, trap_key};
use codeql_extractor::trap;
use ra_ap_hir::db::{DefDatabase, InternDatabase};
@@ -71,13 +71,11 @@ impl CrateTranslator<'_> {
})
}
fn emit_location_for_ast_ptr<T>(
fn emit_location_for_ast_ptr<L: Label, T: AstNode>(
&mut self,
label: trap::Label,
label: L,
source: ra_ap_hir::InFile<ra_ap_syntax::AstPtr<T>>,
) where
T: AstNode,
{
) {
source
.file_id
.file_id()
@@ -91,7 +89,7 @@ impl CrateTranslator<'_> {
fn emit_location_for_expr(
&mut self,
label: trap::Label,
label: generated::ElementTrapLabel, // TODO: should be ExprTrapLabel
expr: ra_ap_hir_def::hir::ExprId,
source_map: &BodySourceMap,
) {
@@ -102,7 +100,8 @@ impl CrateTranslator<'_> {
fn emit_location_for_pat(
&mut self,
label: trap::Label,
// should be Pat, but we're using for other entities for now
label: generated::ElementTrapLabel,
pat_id: ra_ap_hir_def::hir::PatId,
source_map: &BodySourceMap,
) {
@@ -116,14 +115,16 @@ impl CrateTranslator<'_> {
pat: &ra_ap_hir_def::hir::LiteralOrConst,
body: &Body,
source_map: &BodySourceMap,
) -> trap::Label {
) -> generated::PatTrapLabel {
match pat {
ra_ap_hir_def::hir::LiteralOrConst::Literal(_literal) => {
let expr = self.trap.emit(generated::LiteralExpr { id: TrapId::Star });
self.trap.emit(generated::LitPat {
self.trap
.emit(generated::LitPat {
id: TrapId::Star,
expr,
expr: expr.into(),
})
.into()
}
ra_ap_hir_def::hir::LiteralOrConst::Const(inner) => {
self.emit_pat(*inner, body, source_map)
@@ -131,9 +132,9 @@ impl CrateTranslator<'_> {
}
}
fn emit_location_for_label(
fn emit_location_for_label<T: Label>(
&mut self,
label: trap::Label,
label: T,
label_id: ra_ap_hir_def::hir::LabelId,
source_map: &BodySourceMap,
) {
@@ -143,7 +144,7 @@ impl CrateTranslator<'_> {
self.emit_location_for_ast_ptr(label, source)
}
}
fn emit_location<T: HasSource>(&mut self, label: trap::Label, entity: T)
fn emit_location<L: Label, T: HasSource>(&mut self, label: L, entity: T)
where
T::Ast: AstNode,
{
@@ -156,9 +157,9 @@ impl CrateTranslator<'_> {
self.emit_location_for_textrange(label, data, range);
});
}
fn emit_location_for_textrange(
fn emit_location_for_textrange<L: Label>(
&mut self,
label: trap::Label,
label: L,
data: FileData,
range: TextRange,
) {
@@ -176,7 +177,7 @@ impl CrateTranslator<'_> {
label_id: LabelId,
body: &Body,
source_map: &BodySourceMap,
) -> trap::Label {
) -> generated::LabelTrapLabel {
let label = &body.labels[label_id];
let ret = self.trap.emit(generated::Label {
id: TrapId::Star,
@@ -186,11 +187,11 @@ impl CrateTranslator<'_> {
ret
}
fn emit_unimplemented(&mut self) -> trap::Label {
fn emit_unimplemented(&mut self) -> generated::UnimplementedTrapLabel {
self.trap
.emit(generated::Unimplemented { id: TrapId::Star })
}
fn emit_path(&mut self, _path: &Path) -> trap::Label {
fn emit_path(&mut self, _path: &Path) -> generated::UnimplementedTrapLabel {
self.emit_unimplemented()
}
@@ -199,7 +200,7 @@ impl CrateTranslator<'_> {
field_pat: &RecordFieldPat,
body: &Body,
source_map: &BodySourceMap,
) -> trap::Label {
) -> generated::RecordFieldPatTrapLabel {
let RecordFieldPat { name, pat } = field_pat;
let pat_label = self.emit_pat(*pat, body, source_map);
let ret = self.trap.emit(generated::RecordFieldPat {
@@ -207,7 +208,7 @@ impl CrateTranslator<'_> {
name: name.as_str().into(),
pat: pat_label,
});
self.emit_location_for_pat(ret, *pat, source_map);
self.emit_location_for_pat(ret.into(), *pat, source_map);
ret
}
@@ -216,7 +217,7 @@ impl CrateTranslator<'_> {
field_expr: &RecordLitField,
body: &Body,
source_map: &BodySourceMap,
) -> trap::Label {
) -> generated::RecordLitFieldTrapLabel {
let RecordLitField { name, expr } = field_expr;
let expr_label = self.emit_expr(*expr, body, source_map);
let ret = self.trap.emit(generated::RecordLitField {
@@ -224,39 +225,51 @@ impl CrateTranslator<'_> {
name: name.as_str().into(),
expr: expr_label,
});
self.emit_location_for_expr(ret, *expr, source_map);
// TODO find a way for emitting a location for the whole thing
self.emit_location_for_expr(ret.into(), *expr, source_map);
ret
}
fn emit_pat(&mut self, pat_id: PatId, body: &Body, source_map: &BodySourceMap) -> trap::Label {
fn emit_pat(
&mut self,
pat_id: PatId,
body: &Body,
source_map: &BodySourceMap,
) -> generated::PatTrapLabel {
let pat = &body.pats[pat_id];
let ret = match pat {
ra_ap_hir_def::hir::Pat::Missing => {
self.trap.emit(generated::MissingPat { id: TrapId::Star })
}
ra_ap_hir_def::hir::Pat::Wild => {
self.trap.emit(generated::WildPat { id: TrapId::Star })
}
let ret: generated::PatTrapLabel = match pat {
ra_ap_hir_def::hir::Pat::Missing => self
.trap
.emit(generated::MissingPat { id: TrapId::Star })
.into(),
ra_ap_hir_def::hir::Pat::Wild => self
.trap
.emit(generated::WildPat { id: TrapId::Star })
.into(),
ra_ap_hir_def::hir::Pat::Tuple { args, ellipsis } => {
let args = args
.into_iter()
.map(|pat| self.emit_pat(*pat, body, source_map))
.collect();
let ellipsis_index = ellipsis.and_then(|x| x.try_into().ok());
self.trap.emit(generated::TuplePat {
self.trap
.emit(generated::TuplePat {
id: TrapId::Star,
args,
ellipsis_index,
})
.into()
}
ra_ap_hir_def::hir::Pat::Or(args) => {
let args = args
.into_iter()
.map(|pat| self.emit_pat(*pat, body, source_map))
.collect();
self.trap.emit(generated::OrPat {
self.trap
.emit(generated::OrPat {
id: TrapId::Star,
args,
})
.into()
}
ra_ap_hir_def::hir::Pat::Record {
path,
@@ -268,12 +281,14 @@ impl CrateTranslator<'_> {
.into_iter()
.map(|arg| self.emit_record_field_pat(arg, body, source_map))
.collect();
self.trap.emit(generated::RecordPat {
self.trap
.emit(generated::RecordPat {
id: TrapId::Star,
path,
args,
has_ellipsis: *ellipsis,
})
.into()
}
ra_ap_hir_def::hir::Pat::Range { start, end } => {
let start = start
@@ -282,11 +297,13 @@ impl CrateTranslator<'_> {
let end = end
.as_ref()
.map(|x| self.emit_literal_or_const_pat(x, body, source_map));
self.trap.emit(generated::RangePat {
self.trap
.emit(generated::RangePat {
id: TrapId::Star,
start,
end,
})
.into()
}
ra_ap_hir_def::hir::Pat::Slice {
prefix,
@@ -302,34 +319,42 @@ impl CrateTranslator<'_> {
.into_iter()
.map(|pat| self.emit_pat(*pat, body, source_map))
.collect();
self.trap.emit(generated::SlicePat {
self.trap
.emit(generated::SlicePat {
id: TrapId::Star,
prefix,
slice,
suffix,
})
.into()
}
ra_ap_hir_def::hir::Pat::Path(path) => {
let path = self.emit_path(path);
self.trap.emit(generated::PathPat {
self.trap
.emit(generated::PathPat {
id: TrapId::Star,
path,
})
.into()
}
ra_ap_hir_def::hir::Pat::Lit(expr) => {
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::LitPat {
self.trap
.emit(generated::LitPat {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Pat::Bind { id, subpat } => {
let subpat = subpat.map(|pat| self.emit_pat(pat, body, source_map));
self.trap.emit(generated::BindPat {
self.trap
.emit(generated::BindPat {
id: TrapId::Star,
subpat,
binding_id: body.bindings[*id].name.as_str().into(),
})
.into()
}
ra_ap_hir_def::hir::Pat::TupleStruct {
path,
@@ -341,48 +366,56 @@ impl CrateTranslator<'_> {
.into_iter()
.map(|arg| self.emit_pat(*arg, body, source_map))
.collect();
self.trap.emit(generated::TupleStructPat {
self.trap
.emit(generated::TupleStructPat {
id: TrapId::Star,
path,
args,
ellipsis_index: ellipsis.map(|x| x as usize),
})
.into()
}
ra_ap_hir_def::hir::Pat::Ref { pat, mutability } => {
let pat = self.emit_pat(*pat, body, source_map);
self.trap.emit(generated::RefPat {
self.trap
.emit(generated::RefPat {
id: TrapId::Star,
pat,
is_mut: mutability.is_mut(),
})
.into()
}
ra_ap_hir_def::hir::Pat::Box { inner } => {
let inner = self.emit_pat(*inner, body, source_map);
self.trap.emit(generated::BoxPat {
self.trap
.emit(generated::BoxPat {
id: TrapId::Star,
inner,
})
.into()
}
ra_ap_hir_def::hir::Pat::ConstBlock(expr) => {
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::ConstBlockPat {
self.trap
.emit(generated::ConstBlockPat {
id: TrapId::Star,
expr,
})
.into()
}
};
self.emit_location_for_pat(ret, pat_id, source_map);
self.emit_location_for_pat(ret.into(), pat_id, source_map);
ret
}
fn emit_type_ref(&mut self, _type_ref: &TypeRef) -> trap::Label {
self.emit_unimplemented()
fn emit_type_ref(&mut self, _type_ref: &TypeRef) -> generated::TypeRefTrapLabel {
self.emit_unimplemented().into()
}
fn emit_match_arm(
&mut self,
arm: &MatchArm,
body: &Body,
source_map: &BodySourceMap,
) -> trap::Label {
) -> generated::MatchArmTrapLabel {
let pat = self.emit_pat(arm.pat, body, source_map);
let guard = arm.guard.map(|g| self.emit_expr(g, body, source_map));
let expr = self.emit_expr(arm.expr, body, source_map);
@@ -392,7 +425,8 @@ impl CrateTranslator<'_> {
guard,
expr,
});
self.emit_location_for_pat(ret, arm.pat, source_map);
// TODO find a way to generate a location for the whole match arm
self.emit_location_for_pat(ret.into(), arm.pat, source_map);
ret
}
fn emit_stmt(
@@ -400,7 +434,7 @@ impl CrateTranslator<'_> {
stmt: &Statement,
body: &Body,
source_map: &BodySourceMap,
) -> trap::Label {
) -> generated::StmtTrapLabel {
match stmt {
Statement::Let {
pat,
@@ -424,8 +458,8 @@ impl CrateTranslator<'_> {
else_,
});
// TODO: find a way to get the location of the entire statement
self.emit_location_for_pat(ret, *pat, source_map);
ret
self.emit_location_for_pat(ret.into(), *pat, source_map);
ret.into()
}
Statement::Expr { expr, has_semi } => {
let expr_label = self.emit_expr(*expr, body, source_map);
@@ -435,10 +469,13 @@ impl CrateTranslator<'_> {
has_semicolon: *has_semi,
});
// TODO: find a way to get the location of the entire statement
self.emit_location_for_expr(ret, *expr, source_map);
ret
self.emit_location_for_expr(ret.into(), *expr, source_map);
ret.into()
}
Statement::Item => self.trap.emit(generated::ItemStmt { id: TrapId::Star }),
Statement::Item => self
.trap
.emit(generated::ItemStmt { id: TrapId::Star })
.into(),
}
}
fn emit_expr(
@@ -446,18 +483,21 @@ impl CrateTranslator<'_> {
expr_id: ExprId,
body: &Body,
source_map: &BodySourceMap,
) -> trap::Label {
) -> generated::ExprTrapLabel {
let expr = &body[expr_id];
let ret = match expr {
ra_ap_hir_def::hir::Expr::Missing => {
self.trap.emit(generated::MissingExpr { id: TrapId::Star })
}
let ret: generated::ExprTrapLabel = match expr {
ra_ap_hir_def::hir::Expr::Missing => self
.trap
.emit(generated::MissingExpr { id: TrapId::Star })
.into(),
ra_ap_hir_def::hir::Expr::Path(path) => {
let path = self.emit_path(path);
self.trap.emit(generated::PathExpr {
self.trap
.emit(generated::PathExpr {
id: TrapId::Star,
path,
})
.into()
}
ra_ap_hir_def::hir::Expr::If {
condition,
@@ -467,21 +507,25 @@ impl CrateTranslator<'_> {
let condition = self.emit_expr(*condition, body, source_map);
let then = self.emit_expr(*then_branch, body, source_map);
let else_ = else_branch.map(|x| self.emit_expr(x, body, source_map));
self.trap.emit(generated::IfExpr {
self.trap
.emit(generated::IfExpr {
id: TrapId::Star,
condition,
then,
else_,
})
.into()
}
ra_ap_hir_def::hir::Expr::Let { pat, expr } => {
let pat = self.emit_pat(*pat, body, source_map);
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::LetExpr {
self.trap
.emit(generated::LetExpr {
id: TrapId::Star,
pat,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Block {
id: _,
@@ -495,12 +539,14 @@ impl CrateTranslator<'_> {
.collect();
let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
let label = label.map(|l| self.emit_label(l, body, source_map));
self.trap.emit(generated::BlockExpr {
self.trap
.emit(generated::BlockExpr {
id: TrapId::Star,
statements,
tail,
label,
})
.into()
}
ra_ap_hir_def::hir::Expr::Async {
id: _,
@@ -512,19 +558,23 @@ impl CrateTranslator<'_> {
.map(|stmt| self.emit_stmt(stmt, body, source_map))
.collect();
let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
self.trap.emit(generated::AsyncBlockExpr {
self.trap
.emit(generated::AsyncBlockExpr {
id: TrapId::Star,
statements,
tail,
})
.into()
}
ra_ap_hir_def::hir::Expr::Const(const_block) => {
let expr_id = self.db.lookup_intern_anonymous_const(*const_block).root;
let expr = self.emit_expr(expr_id, body, source_map);
self.trap.emit(generated::ConstExpr {
self.trap
.emit(generated::ConstExpr {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Unsafe {
id: _,
@@ -536,11 +586,13 @@ impl CrateTranslator<'_> {
.map(|stmt| self.emit_stmt(stmt, body, source_map))
.collect();
let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
self.trap.emit(generated::UnsafeBlockExpr {
self.trap
.emit(generated::UnsafeBlockExpr {
id: TrapId::Star,
statements,
tail,
})
.into()
}
ra_ap_hir_def::hir::Expr::Loop {
body: loop_body,
@@ -548,11 +600,13 @@ impl CrateTranslator<'_> {
} => {
let loop_body = self.emit_expr(*loop_body, body, source_map);
let label = label.map(|l| self.emit_label(l, body, source_map));
self.trap.emit(generated::LoopExpr {
self.trap
.emit(generated::LoopExpr {
id: TrapId::Star,
body: loop_body,
label,
})
.into()
}
ra_ap_hir_def::hir::Expr::Call {
callee,
@@ -564,12 +618,14 @@ impl CrateTranslator<'_> {
.into_iter()
.map(|e| self.emit_expr(*e, body, source_map))
.collect();
self.trap.emit(generated::CallExpr {
self.trap
.emit(generated::CallExpr {
id: TrapId::Star,
callee,
args,
is_assignee_expr: *is_assignee_expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::MethodCall {
receiver,
@@ -583,13 +639,15 @@ impl CrateTranslator<'_> {
.map(|e| self.emit_expr(*e, body, source_map))
.collect();
let generic_args = generic_args.as_ref().map(|_args| self.emit_unimplemented());
self.trap.emit(generated::MethodCallExpr {
self.trap
.emit(generated::MethodCallExpr {
id: TrapId::Star,
receiver,
method_name: method_name.as_str().into(),
args,
generic_args,
})
.into()
}
ra_ap_hir_def::hir::Expr::Match { expr, arms } => {
let expr = self.emit_expr(*expr, body, source_map);
@@ -598,55 +656,69 @@ impl CrateTranslator<'_> {
.map(|e| self.emit_match_arm(e, body, source_map))
.collect();
self.trap.emit(generated::MatchExpr {
self.trap
.emit(generated::MatchExpr {
id: TrapId::Star,
expr,
branches,
})
.into()
}
ra_ap_hir_def::hir::Expr::Continue { label } => {
let label = label.map(|l| self.emit_label(l, body, source_map));
self.trap.emit(generated::ContinueExpr {
self.trap
.emit(generated::ContinueExpr {
id: TrapId::Star,
label,
})
.into()
}
ra_ap_hir_def::hir::Expr::Break { expr, label } => {
let expr = expr.map(|e| self.emit_expr(e, body, source_map));
let label = label.map(|l| self.emit_label(l, body, source_map));
self.trap.emit(generated::BreakExpr {
self.trap
.emit(generated::BreakExpr {
id: TrapId::Star,
expr,
label,
})
.into()
}
ra_ap_hir_def::hir::Expr::Return { expr } => {
let expr = expr.map(|e| self.emit_expr(e, body, source_map));
self.trap.emit(generated::ReturnExpr {
self.trap
.emit(generated::ReturnExpr {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Become { expr } => {
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::BecomeExpr {
self.trap
.emit(generated::BecomeExpr {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Yield { expr } => {
let expr = expr.map(|e| self.emit_expr(e, body, source_map));
self.trap.emit(generated::YieldExpr {
self.trap
.emit(generated::YieldExpr {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Yeet { expr } => {
let expr = expr.map(|e| self.emit_expr(e, body, source_map));
self.trap.emit(generated::YeetExpr {
self.trap
.emit(generated::YeetExpr {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::RecordLit {
path, //TODO
@@ -661,7 +733,8 @@ impl CrateTranslator<'_> {
.map(|field| self.emit_record_lit_field(field, body, source_map))
.collect();
let spread = spread.map(|expr_id| self.emit_expr(expr_id, body, source_map));
self.trap.emit(generated::RecordLitExpr {
self.trap
.emit(generated::RecordLitExpr {
id: TrapId::Star,
path,
fields,
@@ -669,30 +742,37 @@ impl CrateTranslator<'_> {
has_ellipsis: *ellipsis,
is_assignee_expr: *is_assignee_expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Field { expr, name } => {
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::FieldExpr {
self.trap
.emit(generated::FieldExpr {
id: TrapId::Star,
expr,
name: name.as_str().into(),
})
.into()
}
ra_ap_hir_def::hir::Expr::Await { expr } => {
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::AwaitExpr {
self.trap
.emit(generated::AwaitExpr {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Cast { expr, type_ref } => {
let expr: trap::Label = self.emit_expr(*expr, body, source_map);
let type_ref: trap::Label = self.emit_type_ref(type_ref.as_ref());
self.trap.emit(generated::CastExpr {
let expr = self.emit_expr(*expr, body, source_map);
let type_ref = self.emit_type_ref(type_ref.as_ref());
self.trap
.emit(generated::CastExpr {
id: TrapId::Star,
expr,
type_ref,
})
.into()
}
ra_ap_hir_def::hir::Expr::Ref {
expr,
@@ -700,19 +780,23 @@ impl CrateTranslator<'_> {
mutability,
} => {
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::RefExpr {
self.trap
.emit(generated::RefExpr {
id: TrapId::Star,
expr,
is_mut: mutability.is_mut(),
is_raw: rawness.is_raw(),
})
.into()
}
ra_ap_hir_def::hir::Expr::Box { expr } => {
let expr = self.emit_expr(*expr, body, source_map);
self.trap.emit(generated::BoxExpr {
self.trap
.emit(generated::BoxExpr {
id: TrapId::Star,
expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::UnaryOp { expr, op } => {
let expr = self.emit_expr(*expr, body, source_map);
@@ -721,22 +805,26 @@ impl CrateTranslator<'_> {
ra_ap_syntax::ast::UnaryOp::Not => "!",
ra_ap_syntax::ast::UnaryOp::Neg => "-",
};
self.trap.emit(generated::UnaryOpExpr {
self.trap
.emit(generated::UnaryOpExpr {
id: TrapId::Star,
expr,
op: op.into(),
})
.into()
}
ra_ap_hir_def::hir::Expr::BinaryOp { lhs, rhs, op } => {
let lhs = self.emit_expr(*lhs, body, source_map);
let rhs = self.emit_expr(*rhs, body, source_map);
let op = op.map(|op| format!("{op}"));
self.trap.emit(generated::BinaryOpExpr {
self.trap
.emit(generated::BinaryOpExpr {
id: TrapId::Star,
lhs,
rhs,
op,
})
.into()
}
ra_ap_hir_def::hir::Expr::Range {
lhs,
@@ -745,12 +833,14 @@ impl CrateTranslator<'_> {
} => {
let lhs = lhs.map(|lhs| self.emit_expr(lhs, body, source_map));
let rhs = rhs.map(|rhs| self.emit_expr(rhs, body, source_map));
self.trap.emit(generated::RangeExpr {
self.trap
.emit(generated::RangeExpr {
id: TrapId::Star,
lhs,
rhs,
is_inclusive: *range_type == RangeOp::Inclusive,
})
.into()
}
ra_ap_hir_def::hir::Expr::Index {
base,
@@ -759,12 +849,14 @@ impl CrateTranslator<'_> {
} => {
let base = self.emit_expr(*base, body, source_map);
let index = self.emit_expr(*index, body, source_map);
self.trap.emit(generated::IndexExpr {
self.trap
.emit(generated::IndexExpr {
id: TrapId::Star,
base,
index,
is_assignee_expr: *is_assignee_expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Closure {
args,
@@ -790,7 +882,8 @@ impl CrateTranslator<'_> {
.map(|arg_type| self.emit_type_ref(arg_type))
})
.collect();
self.trap.emit(generated::ClosureExpr {
self.trap
.emit(generated::ClosureExpr {
id: TrapId::Star,
args,
arg_types,
@@ -799,6 +892,7 @@ impl CrateTranslator<'_> {
closure_kind: format!("{:?}", closure_kind),
is_move: *capture_by == CaptureBy::Value,
})
.into()
}
ra_ap_hir_def::hir::Expr::Tuple {
exprs,
@@ -808,11 +902,13 @@ impl CrateTranslator<'_> {
.into_iter()
.map(|expr| self.emit_expr(*expr, body, source_map))
.collect();
self.trap.emit(generated::TupleExpr {
self.trap
.emit(generated::TupleExpr {
id: TrapId::Star,
exprs,
is_assignee_expr: *is_assignee_expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Array(ra_ap_hir_def::hir::Array::ElementList {
elements,
@@ -822,60 +918,70 @@ impl CrateTranslator<'_> {
.into_iter()
.map(|expr| self.emit_expr(*expr, body, source_map))
.collect();
self.trap.emit(generated::ElementListExpr {
self.trap
.emit(generated::ElementListExpr {
id: TrapId::Star,
elements,
is_assignee_expr: *is_assignee_expr,
})
.into()
}
ra_ap_hir_def::hir::Expr::Array(ra_ap_hir_def::hir::Array::Repeat {
initializer,
repeat,
}) => {
let initializer: trap::Label = self.emit_expr(*initializer, body, source_map);
let repeat: trap::Label = self.emit_expr(*repeat, body, source_map);
let initializer = self.emit_expr(*initializer, body, source_map);
let repeat = self.emit_expr(*repeat, body, source_map);
self.trap.emit(generated::RepeatExpr {
self.trap
.emit(generated::RepeatExpr {
id: TrapId::Star,
initializer,
repeat,
})
.into()
}
ra_ap_hir_def::hir::Expr::Literal(_literal) => {
self.trap.emit(generated::LiteralExpr { id: TrapId::Star })
}
ra_ap_hir_def::hir::Expr::Literal(_literal) => self
.trap
.emit(generated::LiteralExpr { id: TrapId::Star })
.into(),
ra_ap_hir_def::hir::Expr::Underscore => self
.trap
.emit(generated::UnderscoreExpr { id: TrapId::Star }),
.emit(generated::UnderscoreExpr { id: TrapId::Star })
.into(),
ra_ap_hir_def::hir::Expr::OffsetOf(offset) => {
let container = self.emit_type_ref(&offset.container);
let fields = offset.fields.iter().map(|x| x.as_str().into()).collect();
self.trap.emit(generated::OffsetOfExpr {
self.trap
.emit(generated::OffsetOfExpr {
id: TrapId::Star,
container,
fields,
})
.into()
}
ra_ap_hir_def::hir::Expr::InlineAsm(asm) => {
let expr = self.emit_expr(asm.e, body, source_map);
self.trap.emit(generated::InlineAsmExpr {
self.trap
.emit(generated::InlineAsmExpr {
id: TrapId::Star,
expr,
})
.into()
}
};
self.emit_location_for_expr(ret, expr_id, source_map);
self.emit_location_for_expr(ret.into(), expr_id, source_map);
ret
}
fn emit_definition(
&mut self,
module_label: trap::Label,
module_label: generated::ModuleTrapLabel,
id: ModuleDef,
labels: &mut Vec<trap::Label>,
labels: &mut Vec<generated::DeclarationTrapLabel>,
) {
let _label = match id {
ModuleDef::Module(_) => self.emit_unimplemented(),
let label: generated::DeclarationTrapLabel = match id {
ModuleDef::Module(_) => self.emit_unimplemented().into(),
ModuleDef::Function(function) => {
let def: ra_ap_hir::DefWithBody = function.into();
@@ -887,7 +993,9 @@ impl CrateTranslator<'_> {
log::trace!("{}", &txt);
self.emit_expr(body.body_expr, &body, &source_map)
} else {
self.trap.emit(generated::MissingExpr { id: TrapId::Star })
self.trap
.emit(generated::MissingExpr { id: TrapId::Star })
.into()
};
let label = self.trap.emit(generated::Function {
id: trap_key![module_label, name.as_str()],
@@ -895,57 +1003,54 @@ impl CrateTranslator<'_> {
body,
});
self.emit_location(label, function);
// TODO: move this below to add all to module children. For now this causes a
// DB inconsistency
labels.push(label);
label
label.into()
}
ModuleDef::Adt(adt) => {
let label = self.emit_unimplemented();
self.emit_location(label, adt);
label
label.into()
}
ModuleDef::Variant(variant) => {
let label = self.emit_unimplemented();
self.emit_location(label, variant);
label
label.into()
}
ModuleDef::Const(const_) => {
let label = self.emit_unimplemented();
self.emit_location(label, const_);
label
label.into()
}
ModuleDef::Static(static_) => {
let label = self.emit_unimplemented();
self.emit_location(label, static_);
label
label.into()
}
ModuleDef::Trait(trait_) => {
let label = self.emit_unimplemented();
self.emit_location(label, trait_);
label
label.into()
}
ModuleDef::TraitAlias(alias) => {
let label = self.emit_unimplemented();
self.emit_location(label, alias);
label
label.into()
}
ModuleDef::TypeAlias(type_alias) => {
let label = self.emit_unimplemented();
self.emit_location(label, type_alias);
label
label.into()
}
ModuleDef::BuiltinType(_builtin_type) => self.emit_unimplemented(),
ModuleDef::BuiltinType(_builtin_type) => self.emit_unimplemented().into(),
ModuleDef::Macro(macro_) => {
let label = self.emit_unimplemented();
self.emit_location(label, macro_);
label
label.into()
}
};
//TODO: labels.push(label) for all, not just functions
labels.push(label);
}
fn emit_module(&mut self, label: trap::Label, module: Module) {
fn emit_module(&mut self, label: generated::ModuleTrapLabel, module: Module) {
let mut children = Vec::new();
for id in module.declarations(self.db) {
self.emit_definition(label, id, &mut children);
@@ -958,7 +1063,7 @@ impl CrateTranslator<'_> {
pub fn emit_crate(&mut self) -> std::io::Result<()> {
self.emit_file(self.krate.root_file(self.db));
let mut map = HashMap::<Module, trap::Label>::new();
let mut map = HashMap::<Module, generated::ModuleTrapLabel>::new();
for module in self.krate.modules(self.db) {
let mut key = String::new();
if let Some(parent) = module.parent(self.db) {
@@ -975,7 +1080,7 @@ impl CrateTranslator<'_> {
if let Some(name) = module.name(self.db) {
key.push_str(name.as_str());
}
let label = self.trap.label(TrapId::Key(key));
let label = self.trap.label(TrapId::<generated::Module>::Key(key));
map.insert(module, label);
self.emit_module(label, module);
}

65
rust/extractor/src/trap.rs
View File

@@ -5,14 +5,18 @@ use log::debug;
use ra_ap_ide_db::line_index::LineCol;
use std::ffi::OsString;
use std::fmt::Debug;
use std::hash::Hash;
use std::path::{Path, PathBuf};
pub use trap::Label as UntypedLabel;
pub use trap::{Arg, Writer};
//TODO: typed labels
pub trait AsTrapKeyPart {
fn as_key_part(&self) -> String;
}
impl AsTrapKeyPart for trap::Label {
impl AsTrapKeyPart for UntypedLabel {
fn as_key_part(&self) -> String {
format!("{{{}}}", self)
}
@@ -31,27 +35,27 @@ impl AsTrapKeyPart for &str {
}
#[derive(Debug, Clone)]
pub enum TrapId {
pub enum TrapId<T: TrapEntry> {
Star,
Key(String),
Label(trap::Label),
Label(T::Label),
}
impl From<String> for TrapId {
impl<T: TrapEntry> From<String> for TrapId<T> {
fn from(value: String) -> Self {
TrapId::Key(value)
}
}
impl From<&str> for TrapId {
impl<T: TrapEntry> From<&str> for TrapId<T> {
fn from(value: &str) -> Self {
TrapId::Key(value.into())
}
}
impl From<trap::Label> for TrapId {
fn from(value: trap::Label) -> Self {
TrapId::Label(value)
impl<T: TrapEntry> From<UntypedLabel> for TrapId<T> {
fn from(value: UntypedLabel) -> Self {
TrapId::Label(value.into())
}
}
@@ -66,9 +70,23 @@ macro_rules! trap_key {
}};
}
pub trait TrapEntry: std::fmt::Debug {
fn extract_id(&mut self) -> TrapId;
fn emit(self, id: trap::Label, out: &mut trap::Writer);
pub trait Label: From<UntypedLabel> + Clone + Debug + Hash + Into<Arg> {
fn as_untyped(&self) -> UntypedLabel;
fn as_key_part(&self) -> String {
self.as_untyped().as_key_part()
}
}
pub trait TrapClass {
type Label: Label;
}
pub trait TrapEntry: std::fmt::Debug + TrapClass + Sized {
fn class_name() -> &'static str;
fn extract_id(&mut self) -> TrapId<Self>;
fn emit(self, id: Self::Label, out: &mut trap::Writer);
}
pub struct TrapFile {
@@ -78,10 +96,10 @@ pub struct TrapFile {
}
impl TrapFile {
pub fn emit_location(
pub fn emit_location<L: Label>(
&mut self,
file_label: trap::Label,
entity_label: trap::Label,
file_label: UntypedLabel,
entity_label: L,
start: LineCol,
end: LineCol,
) {
@@ -101,10 +119,7 @@ impl TrapFile {
);
self.writer.add_tuple(
"locatable_locations",
vec![
trap::Arg::Label(entity_label),
trap::Arg::Label(location_label),
],
vec![entity_label.into(), location_label.into()],
);
}
@@ -112,17 +127,21 @@ impl TrapFile {
extractor::populate_file(&mut self.writer, absolute_path)
}
pub fn label(&mut self, id: TrapId) -> trap::Label {
pub fn label<T: TrapEntry>(&mut self, id: TrapId<T>) -> T::Label {
match id {
TrapId::Star => self.writer.fresh_id(),
TrapId::Key(s) => self.writer.global_id(&s).0,
TrapId::Star => self.writer.fresh_id().into(),
TrapId::Key(s) => self
.writer
.global_id(&format!("{},{}", T::class_name(), s))
.0
.into(),
TrapId::Label(l) => l,
}
}
pub fn emit<T: TrapEntry>(&mut self, mut e: T) -> trap::Label {
pub fn emit<T: TrapEntry>(&mut self, mut e: T) -> T::Label {
let label = self.label(e.extract_id());
e.emit(label, &mut self.writer);
e.emit(label.clone(), &mut self.writer);
label
}

13
rust/ql/.generated.list generated
View File

@@ -111,7 +111,6 @@ lib/codeql/rust/elements/TuplePatConstructor.qll 505c4f440b47da576acd7e3fc69d6b4
lib/codeql/rust/elements/TupleStructPat.qll 50b7d89498dbe6737d97325037156c7689fd8d7e776d66fef9551f173fa3f2d6 f42edcf42be877424ecf2f11c90166a90f485249b24d73ed302294299d6a9bcd
lib/codeql/rust/elements/TupleStructPatConstructor.qll 15a15362572ac2dc98ed3257f195f20bb8dfe34a1fe203cf2a1a193ce16c406f 9e590b50cf865f6bc573b6fc17acea073f0d9389be241b01e820d9f3f8f14acb
lib/codeql/rust/elements/TypeRef.qll 223844544eab3e07b6edda805c6344fa8b486aeea7bbe62e4b98e235ce2008d8 7517748b0e7a57c925168f5ce7a31ecc1b59f7521a2095578f599b8d9045a4e5
lib/codeql/rust/elements/TypeRefConstructor.qll f8b2e5ef15517890a8b2d56643f471ae64cc74c420187049e33b182417e72e4f 683611e732b842756e301a77625b385bca0c4969971020c9e11220a1aa665a29
lib/codeql/rust/elements/UnaryOpExpr.qll 32e637510c03653cc28cb9a25a2873e9bf346aeb63ad2d7a571bfcbda45c59ce 044b22dd35491f9eafc6488fff5bc929aed12e2f36ac55883925c876978bf7cf
lib/codeql/rust/elements/UnaryOpExprConstructor.qll 43db7afbd3535b7edc801d99d772233a734f4ed31eeee2ca74e7ab26cae33e87 7345f8d4cb958ee2fa83d3634285f12829bdd1cbac2697236d6fae062313ab6d
lib/codeql/rust/elements/UnderscoreExpr.qll cd49049149e268524412a17394daaef696ddca63f1f452b369172b9643e94d82 228568c12efc7c055f2ff7cc08c2d0ae150f6356f77ccea98b7f8be3d6bb4806
@@ -171,14 +170,14 @@ lib/codeql/rust/generated/MissingPat.qll 0d8034cee20bacf07ebb9337c797f53a25686a1
lib/codeql/rust/generated/Module.qll 2a931a4f2cdb2fee00ed83af045ea63d36b7dbd708e58c30445b5610feaae333 cd62add5c31a509f965aa294f44a1607ec7c62e3a9e3fe9ee063b3c814f4eb62
lib/codeql/rust/generated/OffsetOfExpr.qll 58dfd632efcb48de7fe6ffbcb2192fcf95bfabdb407a751133f63a0e32ae7489 21ebb1b3d66849fc21c04083cfa751eb56c55809cd52664020bd61ccfbe5ea68
lib/codeql/rust/generated/OrPat.qll f8fe5c7b83a08dabcc530484a696274930040ea13501ae20f1426faeec67bcf0 f3adb3148890531b698570a48740335983a5e81977ba4ac651778f940f184398
lib/codeql/rust/generated/ParentChild.qll e1658ad4b3406b882726ed623e3668b99d1353c92c22f2939e2b7fc2b4053711 739da3c782d40cbd83c2b1d752376a0363802b64b950bea61e79cfb63bdd4f6d
lib/codeql/rust/generated/ParentChild.qll f101e2538cd97f54651d995271dda8ecf5d80a204522506b01994a2e37cfac7a 5d1ef956058bb407f3038787b2be2127afdc2a6910a434cce8dd35037c8841a3
lib/codeql/rust/generated/Pat.qll fe1c72856442dbab5655eff93f86c2cbce8d69d9fa1f99a0f9203061ea1112a4 d85d86e8b6c48df733589d186f610b1cd9086629180701e017774bddc62402c7
lib/codeql/rust/generated/PathExpr.qll 3664ed2ad08097e4446b0fdad148118c754f8203541ae588d967ba9d79b6bf21 0d987d2358fe9b42e57585e7ae906de80e9f4ccf7c20e1d9bb7624ffbad96941
lib/codeql/rust/generated/PathPat.qll acc4dda795bae97626a8d0041538f3ba1f0b591c743fed381cf198a8b04653cb c3deee1b3bb9bd37ae3ed4761d8ee2f498384fe5e1f5e31c0f9b99dfd864a0d5
lib/codeql/rust/generated/PureSynthConstructors.qll 5eb1fc4f6a04172c34ae31e4931e4bf1f8b72fbe414c5f644731a45372d13573 5eb1fc4f6a04172c34ae31e4931e4bf1f8b72fbe414c5f644731a45372d13573
lib/codeql/rust/generated/RangeExpr.qll f499d8c1f260d6262a55c1f3640aaee832ed8c9aac922cb2e05fefbca4509053 a01563640bc23fbce9d33da756bc209fd16155dc76a7fed4ba325979723f48a5
lib/codeql/rust/generated/RangePat.qll 6ec95f6cb9c4bd93b38990bb1e3b89b526624305ac6ee7b94e6fb0a2f3db28fc 0e193f3816a7587d5103dba421bc2bf22b869522353d4e3f43d49a792eac6cf4
lib/codeql/rust/generated/Raw.qll fcc1c9f3b06f7c1ae5ad6f7e7ab508c5fbbe9f13a5888db7e1a1e878d53b0f7e 45b6ee33b3ebe83d7f297eb0a9700da42648dc6228caed1e6649e940ea304907
lib/codeql/rust/generated/Raw.qll 8d6b4ff602a89f779b15d84885b1d165ab23e9fc8b5953d1dfd3294daf492d8d 04366012c0d1278ed49b753d1d39cf96fbb16f7319072e2ff9714d1ecdd224c3
lib/codeql/rust/generated/RecordFieldPat.qll 26bed2285d849b9b7ac52d86131eacb40df912db350e423e81fb98c393c08a69 05ed735aecee90901a1bdfae05d9f85d7f6581616eca3a9262fdef6673222f9b
lib/codeql/rust/generated/RecordLitExpr.qll 1d3264446ff57e8b169f1ad6da150b2d457d6b60eda0ff63e2353eb8ef9e9113 f523dd5ce7f4bac0aafab7b27c6cfe766c72a9ee0c92d7a263347e67edf096df
lib/codeql/rust/generated/RecordLitField.qll bc704b56a986f3a399dc9c3dc2b61cca0d40cd389c694b9fe13374780835ffcc ab6b05a87f240a97cc2a8c15bb84a1338ad33ce367619125a8514e8815fd050e
@@ -189,15 +188,15 @@ lib/codeql/rust/generated/RepeatExpr.qll 43aff00e966e4550179d756489e4cbc30618d66
lib/codeql/rust/generated/ReturnExpr.qll 6160f3a14ff1cbd6a297edae015769f90e8e31201639828d8a9d0d6e38c1ef99 b8c8a12f78281e558d230c6959236780758e9645fe22aca697b948535c20f9be
lib/codeql/rust/generated/SlicePat.qll b4de6692eebf1205940e04da963adc20a07b15923c3c3a7a512a24e3bd8342c9 ee9b919983807f39d97cfe8ca66b76bdbfde76db02db5c93268ce22cbddf4213
lib/codeql/rust/generated/Stmt.qll 55688c8f42f6e7fd1b871e572d75fac60d0543e38c4be4638abbb00187651d3d f978006a8453137f989249e849a7c935a090da3a9b0116145da80068760e12fd
lib/codeql/rust/generated/Synth.qll 6d1c4648a7f705bf5d7e8f8081f835c03feb6eee99bbf5fcca825902cb0cac20 620582c3743f8e0172288660bf5b2f344d8696620675ad0a04df20da55ba9c45
lib/codeql/rust/generated/SynthConstructors.qll 15f62ecc76505a326df6a6d61896892ecbacdd1edc8bb4fede39f1a84e36431e 15f62ecc76505a326df6a6d61896892ecbacdd1edc8bb4fede39f1a84e36431e
lib/codeql/rust/generated/Synth.qll 98478a5bd0cf16a11b4dc64d4d7d7d4bcd61ee637b29ae59af93938393f804f9 e254397b85bbf3c2254c163f010cc90d08a5c658eed461778e97346e4e60ff2c
lib/codeql/rust/generated/SynthConstructors.qll 6cfce4c3bfb6c68cf2fa518cf9cadf0fd968219cb97a60be8e471205d459a553 6cfce4c3bfb6c68cf2fa518cf9cadf0fd968219cb97a60be8e471205d459a553
lib/codeql/rust/generated/TupleExpr.qll 13e4dbc1afcabf388c793145cd399789f4014662f2eed1d49cbe96eeb8355413 bfa0708885c120bad24e29deb29641c69a5e5361654f3a144ead9543bfbd7197
lib/codeql/rust/generated/TuplePat.qll 23911b2ac7ee2279df8ef40a6e447437ef0ed62518504b17874a7652bf5e3f4b fc4f6f7ea40754290de194ac55939f08549bd637104baf8dc84ca3938bcbd1f1
lib/codeql/rust/generated/TupleStructPat.qll fff004cce780501eac94fe4b146619a84e02c85cae12ffeba5a4058e8c9738ea 738659f8208aa65d1d8cf601e0d92a90a890d6cbaec51cf04c81fc75a827e30b
lib/codeql/rust/generated/TypeRef.qll 7cc468c2f473ee13c11a97c4360100376560e8fc42f25a136f1500fe31a31533 7cc468c2f473ee13c11a97c4360100376560e8fc42f25a136f1500fe31a31533
lib/codeql/rust/generated/TypeRef.qll 3e8321504060e2e558e6679555e32c8056969806fc367867d4a76f67b9993558 0df712b2e10d366ced1c6518754ba2f56e1a71fc39753234a321c31f46aa3fba
lib/codeql/rust/generated/UnaryOpExpr.qll fd55d4bc9cd1a49d1f38f02fef16771f29bb5fb2512abd18341d56665859d18c f271ef5036410c018f48d6f15b17cb9beaf4111a42fc638ac4ed3db974a5f870
lib/codeql/rust/generated/UnderscoreExpr.qll cd7f615e41562b80d89e413c1c808048da7746fd445f0eb6ad8c5d9996b44d5d cd7f615e41562b80d89e413c1c808048da7746fd445f0eb6ad8c5d9996b44d5d
lib/codeql/rust/generated/Unimplemented.qll 375b7935b7f4103728ece3042282ae82d19e471d7a9fa58c8cbdea31ea0cb113 375b7935b7f4103728ece3042282ae82d19e471d7a9fa58c8cbdea31ea0cb113
lib/codeql/rust/generated/Unimplemented.qll e2b1da6123c7ff71f9ce1133ae2665ac4e1c401084b0eb778aa4ae78cad2d363 e2b1da6123c7ff71f9ce1133ae2665ac4e1c401084b0eb778aa4ae78cad2d363
lib/codeql/rust/generated/UnsafeBlockExpr.qll 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e
lib/codeql/rust/generated/WildPat.qll 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8
lib/codeql/rust/generated/YeetExpr.qll 2b37cf55ec26958cf226885e99d81c8bbc6ece69fbe92d9fcc8884ee0bc4aad4 e371531507311ea8a9fbaac74442fe9994ae85f0acdb79cc870e5318af52aba9

1
rust/ql/.gitattributes generated vendored
View File

@@ -113,7 +113,6 @@
/lib/codeql/rust/elements/TupleStructPat.qll linguist-generated
/lib/codeql/rust/elements/TupleStructPatConstructor.qll linguist-generated
/lib/codeql/rust/elements/TypeRef.qll linguist-generated
/lib/codeql/rust/elements/TypeRefConstructor.qll linguist-generated
/lib/codeql/rust/elements/UnaryOpExpr.qll linguist-generated
/lib/codeql/rust/elements/UnaryOpExprConstructor.qll linguist-generated
/lib/codeql/rust/elements/UnderscoreExpr.qll linguist-generated

14
rust/ql/lib/codeql/rust/elements/TypeRefConstructor.qll
View File

@@ -1,14 +0,0 @@
// generated by codegen, remove this comment if you wish to edit this file
/**
* This module defines the hook used internally to tweak the characteristic predicate of
* `TypeRef` synthesized instances.
* INTERNAL: Do not use.
*/
private import codeql.rust.generated.Raw
/**
* The characteristic predicate of `TypeRef` synthesized instances.
* INTERNAL: Do not use.
*/
predicate constructTypeRef(Raw::TypeRef id) { any() }

41
rust/ql/lib/codeql/rust/generated/ParentChild.qll generated
View File

@@ -174,21 +174,6 @@ private module Impl {
)
}
private Element getImmediateChildOfUnimplemented(
Unimplemented e, int index, string partialPredicateCall
) {
exists(int b, int bAstNode, int n |
b = 0 and
bAstNode = b + 1 + max(int i | i = -1 or exists(getImmediateChildOfAstNode(e, i, _)) | i) and
n = bAstNode and
(
none()
or
result = getImmediateChildOfAstNode(e, index - b, partialPredicateCall)
)
)
}
private Element getImmediateChildOfArrayExpr(ArrayExpr e, int index, string partialPredicateCall) {
exists(int b, int bExpr, int n |
b = 0 and
@@ -1081,6 +1066,26 @@ private module Impl {
)
}
private Element getImmediateChildOfUnimplemented(
Unimplemented e, int index, string partialPredicateCall
) {
exists(int b, int bDeclaration, int bTypeRef, int n |
b = 0 and
bDeclaration =
b + 1 + max(int i | i = -1 or exists(getImmediateChildOfDeclaration(e, i, _)) | i) and
bTypeRef =
bDeclaration + 1 + max(int i | i = -1 or exists(getImmediateChildOfTypeRef(e, i, _)) | i) and
n = bTypeRef and
(
none()
or
result = getImmediateChildOfDeclaration(e, index - b, partialPredicateCall)
or
result = getImmediateChildOfTypeRef(e, index - bDeclaration, partialPredicateCall)
)
)
}
private Element getImmediateChildOfWildPat(WildPat e, int index, string partialPredicateCall) {
exists(int b, int bPat, int n |
b = 0 and
@@ -1227,10 +1232,6 @@ private module Impl {
or
result = getImmediateChildOfRecordLitField(e, index, partialAccessor)
or
result = getImmediateChildOfTypeRef(e, index, partialAccessor)
or
result = getImmediateChildOfUnimplemented(e, index, partialAccessor)
or
result = getImmediateChildOfAwaitExpr(e, index, partialAccessor)
or
result = getImmediateChildOfBecomeExpr(e, index, partialAccessor)
@@ -1325,6 +1326,8 @@ private module Impl {
or
result = getImmediateChildOfUnderscoreExpr(e, index, partialAccessor)
or
result = getImmediateChildOfUnimplemented(e, index, partialAccessor)
or
result = getImmediateChildOfWildPat(e, index, partialAccessor)
or
result = getImmediateChildOfYeetExpr(e, index, partialAccessor)

18
rust/ql/lib/codeql/rust/generated/Raw.qll generated
View File

@@ -111,16 +111,7 @@ module Raw {
/**
* INTERNAL: Do not use.
*/
class TypeRef extends @type_ref, AstNode {
override string toString() { result = "TypeRef" }
}
/**
* INTERNAL: Do not use.
*/
class Unimplemented extends @unimplemented, AstNode {
override string toString() { result = "Unimplemented" }
}
class TypeRef extends @type_ref, AstNode { }
/**
* INTERNAL: Do not use.
@@ -931,6 +922,13 @@ module Raw {
override string toString() { result = "UnderscoreExpr" }
}
/**
* INTERNAL: Do not use.
*/
class Unimplemented extends @unimplemented, Declaration, TypeRef {
override string toString() { result = "Unimplemented" }
}
/**
* INTERNAL: Do not use.
*/

49
rust/ql/lib/codeql/rust/generated/Synth.qll generated
View File

@@ -227,10 +227,6 @@ module Synth {
* INTERNAL: Do not use.
*/
TTupleStructPat(Raw::TupleStructPat id) { constructTupleStructPat(id) } or
/**
* INTERNAL: Do not use.
*/
TTypeRef(Raw::TypeRef id) { constructTypeRef(id) } or
/**
* INTERNAL: Do not use.
*/
@@ -270,7 +266,7 @@ module Synth {
*/
class TAstNode =
TDeclaration or TExpr or TLabel or TMatchArm or TPat or TRecordFieldPat or TRecordLitField or
TStmt or TTypeRef or TUnimplemented;
TStmt or TTypeRef;
/**
* INTERNAL: Do not use.
@@ -280,7 +276,7 @@ module Synth {
/**
* INTERNAL: Do not use.
*/
class TDeclaration = TFunction or TModule;
class TDeclaration = TFunction or TModule or TUnimplemented;
/**
* INTERNAL: Do not use.
@@ -310,6 +306,11 @@ module Synth {
*/
class TStmt = TExprStmt or TItemStmt or TLetStmt;
/**
* INTERNAL: Do not use.
*/
class TTypeRef = TUnimplemented;
/**
* INTERNAL: Do not use.
* Converts a raw element to a synthesized `TAsyncBlockExpr`, if possible.
@@ -681,13 +682,6 @@ module Synth {
cached
TTupleStructPat convertTupleStructPatFromRaw(Raw::Element e) { result = TTupleStructPat(e) }
/**
* INTERNAL: Do not use.
* Converts a raw element to a synthesized `TTypeRef`, if possible.
*/
cached
TTypeRef convertTypeRefFromRaw(Raw::Element e) { result = TTypeRef(e) }
/**
* INTERNAL: Do not use.
* Converts a raw element to a synthesized `TUnaryOpExpr`, if possible.
@@ -771,8 +765,6 @@ module Synth {
result = convertStmtFromRaw(e)
or
result = convertTypeRefFromRaw(e)
or
result = convertUnimplementedFromRaw(e)
}
/**
@@ -797,6 +789,8 @@ module Synth {
result = convertFunctionFromRaw(e)
or
result = convertModuleFromRaw(e)
or
result = convertUnimplementedFromRaw(e)
}
/**
@@ -934,6 +928,13 @@ module Synth {
result = convertLetStmtFromRaw(e)
}
/**
* INTERNAL: Do not use.
* Converts a raw DB element to a synthesized `TTypeRef`, if possible.
*/
cached
TTypeRef convertTypeRefFromRaw(Raw::Element e) { result = convertUnimplementedFromRaw(e) }
/**
* INTERNAL: Do not use.
* Converts a synthesized `TAsyncBlockExpr` to a raw DB element, if possible.
@@ -1305,13 +1306,6 @@ module Synth {
cached
Raw::Element convertTupleStructPatToRaw(TTupleStructPat e) { e = TTupleStructPat(result) }
/**
* INTERNAL: Do not use.
* Converts a synthesized `TTypeRef` to a raw DB element, if possible.
*/
cached
Raw::Element convertTypeRefToRaw(TTypeRef e) { e = TTypeRef(result) }
/**
* INTERNAL: Do not use.
* Converts a synthesized `TUnaryOpExpr` to a raw DB element, if possible.
@@ -1395,8 +1389,6 @@ module Synth {
result = convertStmtToRaw(e)
or
result = convertTypeRefToRaw(e)
or
result = convertUnimplementedToRaw(e)
}
/**
@@ -1421,6 +1413,8 @@ module Synth {
result = convertFunctionToRaw(e)
or
result = convertModuleToRaw(e)
or
result = convertUnimplementedToRaw(e)
}
/**
@@ -1557,4 +1551,11 @@ module Synth {
or
result = convertLetStmtToRaw(e)
}
/**
* INTERNAL: Do not use.
* Converts a synthesized `TTypeRef` to a raw DB element, if possible.
*/
cached
Raw::Element convertTypeRefToRaw(TTypeRef e) { result = convertUnimplementedToRaw(e) }
}

1
rust/ql/lib/codeql/rust/generated/SynthConstructors.qll generated
View File

@@ -56,7 +56,6 @@ import codeql.rust.elements.SlicePatConstructor
import codeql.rust.elements.TupleExprConstructor
import codeql.rust.elements.TuplePatConstructor
import codeql.rust.elements.TupleStructPatConstructor
import codeql.rust.elements.TypeRefConstructor
import codeql.rust.elements.UnaryOpExprConstructor
import codeql.rust.elements.UnderscoreExprConstructor
import codeql.rust.elements.UnimplementedConstructor

4
rust/ql/lib/codeql/rust/generated/TypeRef.qll generated
View File

@@ -17,7 +17,5 @@ module Generated {
* INTERNAL: Do not reference the `Generated::TypeRef` class directly.
* Use the subclass `TypeRef`, where the following predicates are available.
*/
class TypeRef extends Synth::TTypeRef, AstNode {
override string getAPrimaryQlClass() { result = "TypeRef" }
}
class TypeRef extends Synth::TTypeRef, AstNode { }
}

5
rust/ql/lib/codeql/rust/generated/Unimplemented.qll generated
View File

@@ -6,7 +6,8 @@
private import codeql.rust.generated.Synth
private import codeql.rust.generated.Raw
import codeql.rust.elements.AstNode
import codeql.rust.elements.Declaration
import codeql.rust.elements.TypeRef
/**
* INTERNAL: This module contains the fully generated definition of `Unimplemented` and should not
@@ -17,7 +18,7 @@ module Generated {
* INTERNAL: Do not reference the `Generated::Unimplemented` class directly.
* Use the subclass `Unimplemented`, where the following predicates are available.
*/
class Unimplemented extends Synth::TUnimplemented, AstNode {
class Unimplemented extends Synth::TUnimplemented, Declaration, TypeRef {
override string getAPrimaryQlClass() { result = "Unimplemented" }
}
}

16
rust/ql/lib/rust.dbscheme
View File

@@ -137,12 +137,12 @@ locatable_locations(
| @record_lit_field
| @stmt
| @type_ref
| @unimplemented
;
@declaration =
@function
| @module
| @unimplemented
;
@expr =
@@ -233,13 +233,9 @@ record_lit_fields(
| @let_stmt
;
type_refs(
unique int id: @type_ref
);
unimplementeds(
unique int id: @unimplemented
);
@type_ref =
@unimplemented
;
@array_expr =
@element_list_expr
@@ -801,6 +797,10 @@ underscore_exprs(
unique int id: @underscore_expr
);
unimplementeds(
unique int id: @unimplemented
);
wild_pats(
unique int id: @wild_pat
);

22
rust/schema.py
View File

@@ -29,11 +29,6 @@ class AstNode(Locatable):
pass
@qltest.skip
class Unimplemented(AstNode):
pass
class Declaration(AstNode):
pass
@@ -95,7 +90,7 @@ class MissingExpr(Expr):
class PathExpr(Expr):
path: Unimplemented | child
path: "Unimplemented" | child
# If {
# condition: ExprId,
@@ -196,7 +191,7 @@ class MethodCallExpr(Expr):
receiver: Expr | child
method_name: string
args: list[Expr] | child
generic_args: optional[Unimplemented] | child
generic_args: optional["Unimplemented"] | child
# pub struct MatchArm {
# pub pat: PatId,
@@ -287,7 +282,7 @@ class RecordLitField(AstNode):
class RecordLitExpr(Expr):
path: optional[Unimplemented] | child
path: optional["Unimplemented"] | child
fields: list[RecordLitField] | child
spread: optional[Expr] | child
has_ellipsis: predicate
@@ -514,7 +509,7 @@ class OrPat(Pat):
class RecordPat(Pat):
path: optional[Unimplemented] | child
path: optional["Unimplemented"] | child
args: list[RecordFieldPat] | child
has_ellipsis: predicate
@@ -535,7 +530,7 @@ class SlicePat(Pat):
class PathPat(Pat):
path: Unimplemented | child
path: "Unimplemented" | child
# Lit(ExprId),
@@ -554,7 +549,7 @@ class BindPat(Pat):
class TupleStructPat(Pat):
path: optional[Unimplemented] | child
path: optional["Unimplemented"] | child
args: list[Pat] | child
ellipsis_index: optional[int]
@@ -575,3 +570,8 @@ class BoxPat(Pat):
class ConstBlockPat(Pat):
expr: Expr | child
@qltest.skip
class Unimplemented(Declaration, TypeRef):
pass