-CARGO_WORKSPACE_DIR = { value = "", relative = true } \ No newline at end of file

- names: [self, ripgrep, webrender, diesel]

- run: cargo xtask metrics ${{ matrix.names }}

- - name: Download ripgrep metrics

- name: ripgrep-${{ github.sha }}

- - name: Download webrender metrics

- name: webrender-${{ github.sha }}

- - name: Download diesel metrics

- name: diesel-${{ github.sha }}

- jq -s ".[0] * .[1] * .[2] * .[3] * .[4]" build.json self.json ripgrep.json webrender.json diesel.json -c >> metrics/metrics.json

-version = "0.2.19"

-checksum = "4e884668cd0c7480504233e951174ddc3b382f7c2666e3b7310b5c4e7b0c37f9"

- "redox_syscall",

- "windows-sys 0.42.0",

- "once_cell",

-version = "0.7.3"

-version = "0.7.3"

-checksum = "72417faa455bfb4e5bf14b157d8e2ca2ed74b4e89b8cf42ea2d864825ae5c8a2"

-version = "5.1.0"

-checksum = "58ea850aa68a06e48fdb069c0ec44d0d64c8dbffa49bf3b6f7f0a901fdea1ba9"

- "bitflags 1.3.2",

- "windows-sys 0.42.0",

- "redox_syscall",

- "redox_syscall",

-version = "0.1.0"

-checksum = "e1c145702ed3f237918e512685185dc8a4d0edc3a5326c63d20361d8ba9b45b3"

- "unic-emoji-char",

- "filetime",

- "lsp-server 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)",

-name = "unic-char-property"

-version = "0.9.0"

-source = "registry+https://github.com/rust-lang/crates.io-index"

-checksum = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"

-dependencies = [

- "unic-char-range",

-]

-

-[[package]]

-name = "unic-char-range"

-version = "0.9.0"

-source = "registry+https://github.com/rust-lang/crates.io-index"

-checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"

-

-[[package]]

-name = "unic-common"

-version = "0.9.0"

-source = "registry+https://github.com/rust-lang/crates.io-index"

-checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"

-

-[[package]]

-name = "unic-emoji-char"

-version = "0.9.0"

-source = "registry+https://github.com/rust-lang/crates.io-index"

-checksum = "0b07221e68897210270a38bde4babb655869637af0f69407f96053a34f76494d"

-dependencies = [

- "unic-char-property",

- "unic-char-range",

- "unic-ucd-version",

-]

-

-[[package]]

-name = "unic-ucd-version"

-version = "0.9.0"

-source = "registry+https://github.com/rust-lang/crates.io-index"

-checksum = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"

-dependencies = [

- "unic-common",

-]

-

-[[package]]

-lsp-server = { version = "0.7.3" }

-# See https://github.com/serde-rs/serde/issues/2538#issuecomment-1684517372 for why we pin serde

-serde = { version = "1.0.156, < 1.0.172", features = ["derive"] }

-rustc_lexer = { version = "0.1.0", package = "ra-ap-rustc_lexer" }

- meta.cfg,

- Default::default(),

- default_cfg = meta.cfg;

- default_cfg,

- Default::default(),

- cargo_handle: Option<CargoHandle>,

- FlycheckActor { id, sender, config, root: workspace_root, cargo_handle: None }

- let check_chan = self.cargo_handle.as_ref().map(|cargo| &cargo.receiver);

- match CargoHandle::spawn(command) {

- Ok(cargo_handle) => {

- tracing::debug!(

- command = ?self.check_command(),

- "did restart flycheck"

- );

- self.cargo_handle = Some(cargo_handle);

- "Failed to run the following command: {:?} error={}",

- self.check_command(),

- error

- let cargo_handle = self.cargo_handle.take().unwrap();

- let res = cargo_handle.join();

- "Flycheck failed to run the following command: {:?}",

- self.check_command()

- if let Some(cargo_handle) = self.cargo_handle.take() {

- command = ?self.check_command(),

- cargo_handle.cancel();

-struct CargoHandle {

-impl CargoHandle {

- fn spawn(mut command: Command) -> std::io::Result<CargoHandle> {

- Ok(CargoHandle { child, thread, receiver })

-rustc_abi = { version = "0.0.20221221", package = "hkalbasi-rustc-ap-rustc_abi", default-features = false }

-rustc_index = { version = "0.0.20221221", package = "hkalbasi-rustc-ap-rustc_index", default-features = false }

-use std::{hash::Hash, ops};

-use itertools::Itertools;

- ast::{self, HasAttrs, IsString},

- AstPtr, AstToken, SmolStr, TextRange, TextSize,

-/// Holds documentation

-#[derive(Debug, Clone, PartialEq, Eq, Hash)]

-pub struct Documentation(String);

-

-impl Documentation {

- pub fn new(s: String) -> Self {

- Documentation(s)

- }

-

- pub fn as_str(&self) -> &str {

- &self.0

- }

-}

-

-impl From<Documentation> for String {

- fn from(Documentation(string): Documentation) -> Self {

- string

- }

-}

-

- pub fn docs(&self) -> Option<Documentation> {

- let docs = self.by_key("doc").attrs().filter_map(|attr| attr.string_value());

- let indent = doc_indent(self);

- let mut buf = String::new();

- for doc in docs {

- // str::lines doesn't yield anything for the empty string

- if !doc.is_empty() {

- buf.extend(Itertools::intersperse(

- doc.lines().map(|line| {

- line.char_indices()

- .nth(indent)

- .map_or(line, |(offset, _)| &line[offset..])

- .trim_end()

- }),

- "\n",

- ));

- }

- buf.push('\n');

- }

- buf.pop();

- if buf.is_empty() {

- None

- } else {

- Some(Documentation(buf))

- }

- }

-

-use std::slice::Iter as SliceIter;

-// #[cfg_attr(test, derive(derive_arbitrary::Arbitrary))]

-

- pub fn docs_with_rangemap(

- &self,

- db: &dyn DefDatabase,

- ) -> Option<(Documentation, DocsRangeMap)> {

- let docs =

- self.by_key("doc").attrs().filter_map(|attr| attr.string_value().map(|s| (s, attr.id)));

- let indent = doc_indent(self);

- let mut buf = String::new();

- let mut mapping = Vec::new();

- for (doc, idx) in docs {

- if !doc.is_empty() {

- let mut base_offset = 0;

- for raw_line in doc.split('\n') {

- let line = raw_line.trim_end();

- let line_len = line.len();

- let (offset, line) = match line.char_indices().nth(indent) {

- Some((offset, _)) => (offset, &line[offset..]),

- None => (0, line),

- };

- let buf_offset = buf.len();

- buf.push_str(line);

- mapping.push((

- TextRange::new(buf_offset.try_into().ok()?, buf.len().try_into().ok()?),

- idx,

- TextRange::at(

- (base_offset + offset).try_into().ok()?,

- line_len.try_into().ok()?,

- ),

- ));

- buf.push('\n');

- base_offset += raw_line.len() + 1;

- }

- } else {

- buf.push('\n');

- }

- }

- buf.pop();

- if buf.is_empty() {

- None

- } else {

- Some((Documentation(buf), DocsRangeMap { mapping, source_map: self.source_map(db) }))

- }

- }

-}

-

-fn doc_indent(attrs: &Attrs) -> usize {

- attrs

- .by_key("doc")

- .attrs()

- .filter_map(|attr| attr.string_value())

- .flat_map(|s| s.lines())

- .filter(|line| !line.chars().all(|c| c.is_whitespace()))

- .map(|line| line.chars().take_while(|c| c.is_whitespace()).count())

- .min()

- .unwrap_or(0)

- fn source_of_id(&self, id: AttrId) -> InFile<&Either<ast::Attr, ast::Comment>> {

-/// A struct to map text ranges from [`Documentation`] back to TextRanges in the syntax tree.

-#[derive(Debug)]

-pub struct DocsRangeMap {

- source_map: AttrSourceMap,

- // (docstring-line-range, attr_index, attr-string-range)

- // a mapping from the text range of a line of the [`Documentation`] to the attribute index and

- // the original (untrimmed) syntax doc line

- mapping: Vec<(TextRange, AttrId, TextRange)>,

-}

-

-impl DocsRangeMap {

- /// Maps a [`TextRange`] relative to the documentation string back to its AST range

- pub fn map(&self, range: TextRange) -> Option<InFile<TextRange>> {

- let found = self.mapping.binary_search_by(|(probe, ..)| probe.ordering(range)).ok()?;

- let (line_docs_range, idx, original_line_src_range) = self.mapping[found];

- if !line_docs_range.contains_range(range) {

- return None;

- }

-

- let relative_range = range - line_docs_range.start();

-

- let InFile { file_id, value: source } = self.source_map.source_of_id(idx);

- match source {

- Either::Left(attr) => {

- let string = get_doc_string_in_attr(attr)?;

- let text_range = string.open_quote_text_range()?;

- let range = TextRange::at(

- text_range.end() + original_line_src_range.start() + relative_range.start(),

- string.syntax().text_range().len().min(range.len()),

- );

- Some(InFile { file_id, value: range })

- }

- Either::Right(comment) => {

- let text_range = comment.syntax().text_range();

- let range = TextRange::at(

- text_range.start()

- + TextSize::try_from(comment.prefix().len()).ok()?

- + original_line_src_range.start()

- + relative_range.start(),

- text_range.len().min(range.len()),

- );

- Some(InFile { file_id, value: range })

- }

- }

- }

-}

-

-fn get_doc_string_in_attr(it: &ast::Attr) -> Option<ast::String> {

- match it.expr() {

- // #[doc = lit]

- Some(ast::Expr::Literal(lit)) => match lit.kind() {

- ast::LiteralKind::String(it) => Some(it),

- _ => None,

- },

- // #[cfg_attr(..., doc = "", ...)]

- None => {

- // FIXME: See highlight injection for what to do here

- None

- }

- _ => None,

- }

-}

-

-use once_cell::sync::OnceCell;

- static BUILTIN_LOOKUP_TABLE: OnceCell<FxHashMap<&'static str, usize>> = OnceCell::new();

- field_map: FxHashMap<FieldSource, ExprId>,

- let (mut body, source_map) =

- pub fn node_field(&self, node: InFile<&ast::RecordExprField>) -> Option<ExprId> {

- let src = node.map(AstPtr::new);

- self.field_map.get(&src).cloned()

- dummy_expr_id, Array, Binding, BindingAnnotation, BindingId, BindingProblems, CaptureBy,

- ClosureKind, Expr, ExprId, Label, LabelId, Literal, LiteralOrConst, MatchArm, Movability,

- Pat, PatId, RecordFieldPat, RecordLitField, Statement,

- self.source_map.field_map.insert(src.clone(), expr);

- ast::Expr::BoxExpr(e) => {

- let expr = self.collect_expr_opt(e.expr());

- self.alloc_expr(Expr::Box { expr }, syntax_ptr)

- }

-

- let condition = self.collect_expr_opt(e.condition());

- let args = p

- .record_pat_field_list()

- .expect("every struct should have a field list")

- let ellipsis = p

- .record_pat_field_list()

- .expect("every struct should have a field list")

- .rest_pat()

- .is_some();

-use hir_expand::db::ExpandDatabase;

- let mut p =

- Printer { db: db.upcast(), body, buf: header, indent_level: 0, needs_indent: false };

- let mut p =

- Printer { db: db.upcast(), body, buf: String::new(), indent_level: 0, needs_indent: false };

- db: &'a dyn ExpandDatabase,

- match self.buf.chars().rev().find(|ch| *ch != ' ') {

- Some('\n') | None => {}

- _ => writeln!(self).unwrap(),

- w!(self, "{}: ", self.body[*lbl].name.display(self.db));

- w!(self, ".{}", method_name.display(self.db));

- w!(self, " {}", self.body[*lbl].name.display(self.db));

- w!(self, " {}", self.body[*lbl].name.display(self.db));

- w!(p, "{}: ", field.name.display(self.db));

- w!(self, ".{}", name.display(self.db));

- let label = label.map(|lbl| format!("{}: ", self.body[lbl].name.display(self.db)));

- w!(p, "{}: ", arg.name.display(self.db));

- w!(self, "{}{}", mode, name.display(self.db));

-use expect_test::Expect;

-fn lower(ra_fixture: &str) -> Arc<Body> {

- db.body(fn_def.unwrap().into())

- );

-) -> Option<ModPath> {

- return Some(ModPath::from_segments(PathKind::Plain, Some(scope_name)));

- return Some(ModPath::from_segments(PathKind::Crate, None));

- return modpath;

- return Some(ModPath::from_segments(kind, Some(name)));

- return value;

-) -> Option<ModPath> {

- path.push_segment(name);

- let new_path = match best_path {

- best_path_len = new_path.len();

- best_path = Some(new_path);

- let mut path = find_path_for_module(

- Some(path)

- let new_path = match best_path {

- best_path = Some(new_path);

- scope_name.map(|scope_name| ModPath::from_segments(prefix, Some(scope_name)))

-fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {

- match (old_path.segments().first(), new_path.segments().first()) {

- if new_path.len() < old_path.len() {

- if new_path.len() < old_path.len() {

- // FIXME: these should have actual values filled in, but unsure on perf impact

- Expr::Path(_) => {}

- // FIXME: Not yet used, but will be once we handle doc(hidden) import sources

- let is_doc_hidden =

- attr_id.map_or(false, |attr_id| db.attrs(attr_id).has_doc_hidden());

- Entry::Vacant(entry) => _ = entry.insert((depth, is_doc_hidden)),

- let &(occ_depth, occ_is_doc_hidden) = entry.get();

- // Prefer the one that is not doc(hidden),

- // Otherwise, if both have the same doc(hidden)-ness and the new path is shorter, prefer that one.

- let overwrite_entry = occ_is_doc_hidden && !is_doc_hidden

- || occ_is_doc_hidden == is_doc_hidden && depth < occ_depth;

- if !overwrite_entry {

- entry.insert((depth, is_doc_hidden));

-

- is_doc_hidden: db.attrs(item.into()).has_doc_hidden(),

- pretty::print_item_tree(db.upcast(), self)

-use hir_expand::db::ExpandDatabase;

-

-pub(super) fn print_item_tree(db: &dyn ExpandDatabase, tree: &ItemTree) -> String {

- db: &'a dyn ExpandDatabase,

- attr.path.display(self.db),

- RawVisibility::Module(path) => w!(self, "pub({}) ", path.display(self.db)),

- w!(this, "{}: ", name.display(self.db));

- w!(this, "{}: ", name.display(self.db));

- w!(self, "{}", path.display(self.db));

- w!(self, "{}::", path.display(self.db));

- w!(self, "{}::", prefix.display(self.db));

- w!(self, "extern crate {}", name.display(self.db));

- w!(self, "fn {}", name.display(self.db));

- w!(self, "struct {}", name.display(self.db));

- w!(self, "union {}", name.display(self.db));

- w!(self, "enum {}", name.display(self.db));

- w!(this, "{}", name.display(self.db));

- Some(name) => w!(self, "{}", name.display(self.db)),

- w!(self, "{}: ", name.display(self.db));

- w!(self, "trait {}", name.display(self.db));

- w!(self, "trait {}", name.display(self.db));

- w!(self, "type {}", name.display(self.db));

- w!(self, "mod {}", name.display(self.db));

- wln!(self, "{}!(...);", path.display(self.db));

- wln!(self, "macro_rules! {} {{ ... }}", name.display(self.db));

- wln!(self, "macro {} {{ ... }}", name.display(self.db));

- w!(self, "{}", lt.name.display(self.db));

- Some(name) => w!(self, "{}", name.display(self.db)),

- w!(self, "const {}: ", konst.name.display(self.db));

- target.name.display(self.db),

- bound.name.display(self.db)

- w!(this, "{}", lt.display(self.db));

- Some(name) => w!(this, "{}", name.display(self.db)),

- Some(Path::LangItem(t))

-use once_cell::unsync::OnceCell;

- ::core::fmt::Arguments::new_v1(&["", " ", ], &[::core::fmt::ArgumentV1::new(&(arg1(a, b, c)), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(arg2), ::core::fmt::Debug::fmt), ]);

- format_args!(x =);

- format_args!(x =, x = 2);

- format_args!("{}", x =);

- format_args!(=, "{}", x =);

- /* error: no rule matches input tokens */;

- /* error: expected expression */;

- /* error: expected expression, expected COMMA */;

- /* error: expected expression */::core::fmt::Arguments::new_v1(&["", ], &[::core::fmt::ArgumentV1::new(&(), ::core::fmt::Display::fmt), ]);

- /* error: expected expression, expected R_PAREN */;

- ::core::fmt::Arguments::new_v1(&["", ], &[::core::fmt::ArgumentV1::new(&(5), ::core::fmt::Display::fmt), ]);

- ::core::fmt::Arguments::new_v1(&["", " ", ], &[::core::fmt::ArgumentV1::new(&(a::<A, B>()), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(b), ::core::fmt::Debug::fmt), ]);

- ::core::fmt::Arguments::new_v1(&[r#""#, r#",mismatch,""#, r#"",""#, r#"""#, ], &[::core::fmt::ArgumentV1::new(&(location_csv_pat(db, &analysis, vfs, &sm, pat_id)), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(mismatch.expected.display(db)), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(mismatch.actual.display(db)), ::core::fmt::Display::fmt), ]);

- ::core::fmt::Arguments::new_v1(&["xxx", "y", "zzz", ], &[::core::fmt::ArgumentV1::new(&(2), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(b), ::core::fmt::Debug::fmt), ]);

- /* error: expected field name or number *//* parse error: expected field name or number */

-::core::fmt::Arguments::new_v1(&["", " ", ], &[::core::fmt::ArgumentV1::new(&(a.), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(), ::core::fmt::Debug::fmt), ]);

- /* error: unresolved macro identity */::core::fmt::Arguments::new_v1(&["", " ", " ", ], &[::core::fmt::ArgumentV1::new(&(::core::fmt::Arguments::new_v1(&["", ], &[::core::fmt::ArgumentV1::new(&(0), ::core::fmt::Display::fmt), ])), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(foo), ::core::fmt::Display::fmt), ::core::fmt::ArgumentV1::new(&(identity!(10)), ::core::fmt::Display::fmt), ])

- // format_args/*+tokenids*/!("{} {} {}"#1,#3 format_args!("{}", 0#10),#12 foo#13,#14 identity!(10#18),#21 "bar"#22)

-::core#4294967295::fmt#4294967295::Arguments#4294967295::new_v1#4294967295(&#4294967295[#4294967295""#4294967295,#4294967295 " "#4294967295,#4294967295 " "#4294967295,#4294967295 ]#4294967295,#4294967295 &#4294967295[::core#4294967295::fmt#4294967295::ArgumentV1#4294967295::new#4294967295(&#4294967295(::core#4294967295::fmt#4294967295::Arguments#4294967295::new_v1#4294967295(&#4294967295[#4294967295""#4294967295,#4294967295 ]#4294967295,#4294967295 &#4294967295[::core#4294967295::fmt#4294967295::ArgumentV1#4294967295::new#4294967295(&#4294967295(#42949672950#10)#4294967295,#4294967295 ::core#4294967295::fmt#4294967295::Display#4294967295::fmt#4294967295)#4294967295,#4294967295 ]#4294967295)#4294967295)#4294967295,#4294967295 ::core#4294967295::fmt#4294967295::Display#4294967295::fmt#4294967295)#4294967295,#4294967295 ::core#4294967295::fmt#4294967295::ArgumentV1#4294967295::new#4294967295(&#4294967295(#4294967295foo#13)#4294967295,#4294967295 ::core#4294967295::fmt#4294967295::Display#4294967295::fmt#4294967295)#4294967295,#4294967295 ::core#4294967295::fmt#4294967295::ArgumentV1#4294967295::new#4294967295(&#4294967295(#429496729510#18)#4294967295,#4294967295 ::core#4294967295::fmt#4294967295::Display#4294967295::fmt#4294967295)#4294967295,#4294967295 ]#4294967295)#4294967295

- /* error: expected field name or number *//* parse error: expected field name or number */

-::core::fmt::Arguments::new_v1(&["", ], &[::core::fmt::ArgumentV1::new(&(line.1.), ::core::fmt::Display::fmt), ]);

- /* error: expected COMMA, expected R_BRACK, expected COMMA, expected COMMA, expected expression, expected R_PAREN *//* parse error: expected COMMA */

-/* parse error: expected R_PAREN */

-/* parse error: expected expression, item or let statement */

-/* parse error: expected expression, item or let statement */

-/* parse error: expected expression, item or let statement */

-::core::fmt::Arguments::new_v1(&["", ], &[::core::fmt::ArgumentV1::new(&(&[0 2]), ::core::fmt::Display::fmt), ]);

- /// When this is a block def map, this will hold the block id of the the block and module that

- self.def_collector.import_macros_from_extern_crate(target_crate, None, Some(extern_crate_id));

- LangItem(LangItemTarget),

- Path::LangItem(_) => &PathKind::Abs,

- Path::LangItem(_) => None,

- let Path::Normal { mod_path, generic_args, .. } = self else {

- return PathSegments { segments: &[], generic_args: None };

- };

- let s =

- PathSegments { segments: mod_path.segments(), generic_args: generic_args.as_deref() };

- if let Some(generic_args) = s.generic_args {

- assert_eq!(s.segments.len(), generic_args.len());

- s

- Path::LangItem(_) => None,

-use hir_expand::{db::ExpandDatabase, mod_path::PathKind};

-pub(crate) fn print_path(db: &dyn ExpandDatabase, path: &Path, buf: &mut dyn Write) -> fmt::Result {

- if let Path::LangItem(it) = path {

- return write!(buf, "$lang_item::{it:?}");

- write!(buf, "{}", segment.name.display(db))?;

- db: &dyn ExpandDatabase,

- write!(buf, "{}", binding.name.display(db))?;

- db: &dyn ExpandDatabase,

- GenericArg::Const(c) => write!(buf, "{}", c.display(db)),

- GenericArg::Lifetime(lt) => write!(buf, "{}", lt.name.display(db)),

- db: &dyn ExpandDatabase,

- write!(buf, "{} ", lt.name.display(db))?;

- write!(buf, "; {}]", len.display(db))?;

- db: &dyn ExpandDatabase,

- write!(buf, "for<{}> ", lifetimes.iter().map(|it| it.display(db)).format(", "))?;

- TypeBound::Lifetime(lt) => write!(buf, "{}", lt.name.display(db))?,

- Path::LangItem(l) => {

- return Some((

- match *l {

- LangItemTarget::Union(it) => TypeNs::AdtId(it.into()),

- LangItemTarget::TypeAlias(it) => TypeNs::TypeAliasId(it),

- LangItemTarget::Struct(it) => TypeNs::AdtId(it.into()),

- LangItemTarget::EnumVariant(it) => TypeNs::EnumVariantId(it),

- LangItemTarget::EnumId(it) => TypeNs::AdtId(it.into()),

- LangItemTarget::Trait(it) => TypeNs::TraitId(it),

- LangItemTarget::Function(_)

- | LangItemTarget::ImplDef(_)

- | LangItemTarget::Static(_) => return None,

- },

- None,

- None,

- ))

- Path::LangItem(l) => {

-use std::mem;

-

-use ::tt::Ident;

-use rustc_hash::FxHashMap;

-

- EAGER:

- end_string: &str,

- let args = parse_exprs_with_sep(tt, ',');

-

- let expand_error =

- ExpandResult::new(tt::Subtree::empty(), mbe::ExpandError::NoMatchingRule.into());

-

- let mut key_args = FxHashMap::default();

- let mut args = args.into_iter().filter_map(|mut arg| {

- // Remove `key =`.

- if matches!(arg.token_trees.get(1), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=')

- {

- // but not with `==`

- if !matches!(arg.token_trees.get(2), Some(tt::TokenTree::Leaf(tt::Leaf::Punct(p))) if p.char == '=')

- {

- let key = arg.token_trees.drain(..2).next().unwrap();

- key_args.insert(key.to_string(), arg);

- return None;

- }

- }

- Some(arg)

- }).collect::<Vec<_>>().into_iter();

- // ^^^^^^^ we need this collect, to enforce the side effect of the filter_map closure (building the `key_args`)

- let Some(format_subtree) = args.next() else {

- return expand_error;

- };

- let format_string = (|| {

- let token_tree = format_subtree.token_trees.get(0)?;

- match token_tree {

- tt::TokenTree::Leaf(l) => match l {

- tt::Leaf::Literal(l) => {

- if let Some(mut text) = l.text.strip_prefix('r') {

- let mut raw_sharps = String::new();

- while let Some(t) = text.strip_prefix('#') {

- text = t;

- raw_sharps.push('#');

- }

- text =

- text.strip_suffix(&raw_sharps)?.strip_prefix('"')?.strip_suffix('"')?;

- Some((text, l.span, Some(raw_sharps)))

- } else {

- let text = l.text.strip_prefix('"')?.strip_suffix('"')?;

- let span = l.span;

- Some((text, span, None))

- }

- }

- _ => None,

- },

- tt::TokenTree::Subtree(_) => None,

- }

- })();

- let Some((format_string, _format_string_span, raw_sharps)) = format_string else {

- return expand_error;

- };

- let mut format_iter = format_string.chars().peekable();

- let mut parts = vec![];

- let mut last_part = String::new();

- let mut arg_tts = vec![];

- let mut err = None;

- while let Some(c) = format_iter.next() {

- // Parsing the format string. See https://doc.rust-lang.org/std/fmt/index.html#syntax for the grammar and more info

- match c {

- '{' => {

- if format_iter.peek() == Some(&'{') {

- format_iter.next();

- last_part.push('{');

- continue;

- }

- let mut argument = String::new();

- while ![Some(&'}'), Some(&':')].contains(&format_iter.peek()) {

- argument.push(match format_iter.next() {

- Some(c) => c,

- None => return expand_error,

- });

- }

- let format_spec = match format_iter.next().unwrap() {

- '}' => "".to_owned(),

- ':' => {

- let mut s = String::new();

- while let Some(c) = format_iter.next() {

- if c == '}' {

- break;

- }

- s.push(c);

- }

- s

- }

- _ => unreachable!(),

- };

- parts.push(mem::take(&mut last_part));

- let arg_tree = if argument.is_empty() {

- match args.next() {

- Some(it) => it,

- None => {

- err = Some(mbe::ExpandError::NoMatchingRule.into());

- tt::Subtree::empty()

- }

- }

- } else if let Some(tree) = key_args.get(&argument) {

- tree.clone()

- } else {

- // FIXME: we should pick the related substring of the `_format_string_span` as the span. You

- // can use `.char_indices()` instead of `.char()` for `format_iter` to find the substring interval.

- let ident = Ident::new(argument, tt::TokenId::unspecified());

- quote!(#ident)

- };

- let formatter = match &*format_spec {

- "?" => quote!(::core::fmt::Debug::fmt),

- "" => quote!(::core::fmt::Display::fmt),

- _ => {

- // FIXME: implement the rest and return expand error here

- quote!(::core::fmt::Display::fmt)

- }

- };

- arg_tts.push(quote! { ::core::fmt::ArgumentV1::new(&(#arg_tree), #formatter), });

- }

- '}' => {

- if format_iter.peek() == Some(&'}') {

- format_iter.next();

- last_part.push('}');

- } else {

- return expand_error;

- }

- }

- _ => last_part.push(c),

- }

- }

- last_part += end_string;

- if !last_part.is_empty() {

- parts.push(last_part);

- }

- let part_tts = parts.into_iter().map(|it| {

- let text = if let Some(raw) = &raw_sharps {

- format!("r{raw}\"{}\"{raw}", it).into()

- } else {

- format!("\"{}\"", it).into()

- };

- let l = tt::Literal { span: tt::TokenId::unspecified(), text };

- quote!(#l ,)

- let arg_tts = arg_tts.into_iter().flat_map(|arg| arg.token_trees);

- let expanded = quote! {

- ::core::fmt::Arguments::new_v1(&[##part_tts], &[##arg_tts])

- };

- ExpandResult { value: expanded, err }

- let expanded = quote! {{

- ##literals

- loop {}

- }};

- let Some(EagerCallInfo { arg,arg_id, .. }) = loc.eager.as_deref() else {

- }

-rustc_index = { version = "0.0.20221221", package = "hkalbasi-rustc-ap-rustc_index", default-features = false }

- pub fn offset<T>(dst: *const T, offset: isize) -> *const T;

- const GOAL: u8 = unsafe {

- let ar: &[(u8, u8, u8)] = &[

- let ar: *const [(u8, u8, u8)] = ar;

- let ar = ar as *const (u8, u8, u8);

- let element = *offset(ar, 2);

- element.1

- 31,

- is_allowed(id)

- // go upwards one step or give up

- || match id {

- AttrDefId::ModuleId(m) => m.containing_module(self.db.upcast()).map(|v| v.into()),

- AttrDefId::FunctionId(f) => Some(f.lookup(self.db.upcast()).container.into()),

- AttrDefId::StaticId(sid) => Some(sid.lookup(self.db.upcast()).container.into()),

- AttrDefId::ConstId(cid) => Some(cid.lookup(self.db.upcast()).container.into()),

- AttrDefId::TraitId(tid) => Some(tid.lookup(self.db.upcast()).container.into()),

- AttrDefId::TraitAliasId(taid) => Some(taid.lookup(self.db.upcast()).container.into()),

- AttrDefId::ImplId(iid) => Some(iid.lookup(self.db.upcast()).container.into()),

- AttrDefId::ExternBlockId(id) => Some(id.lookup(self.db.upcast()).container.into()),

- AttrDefId::ExternCrateId(id) => Some(id.lookup(self.db.upcast()).container.into()),

- AttrDefId::UseId(id) => Some(id.lookup(self.db.upcast()).container.into()),

- AdtId::StructId(sid) => Some(sid.lookup(self.db.upcast()).container.into()),

- AdtId::EnumId(eid) => Some(eid.lookup(self.db.upcast()).container.into()),

- expr: ExprId,

- let Some((expr_inner_ty, _, _)) = expr_ty.as_reference() else { return false; };

- let Some((cast_inner_ty, _)) = cast_ty.as_raw_ptr() else { return false; };

- let TyKind::Array(expr_elt_ty, _) = expr_inner_ty.kind(Interner) else { return false; };

- if let Some(initializer) = initializer {

- self.consume_expr(*initializer);

- }

- return;

- self.walk_expr(*initializer);

- if let Some(variant) = def_id {

- self.write_variant_resolution(tgt_expr.into(), variant);

- }

- let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();

- let variant_data = def_id.map(|it| it.variant_data(self.db.upcast()));

- for field in fields.iter() {

- let field_def =

- variant_data.as_ref().and_then(|it| match it.field(&field.name) {

- Some(local_id) => Some(FieldId { parent: def_id.unwrap(), local_id }),

- None => {

- self.push_diagnostic(InferenceDiagnostic::NoSuchField {

- expr: field.expr,

- });

- None

- }

- });

- let field_ty = field_def.map_or(self.err_ty(), |it| {

- field_types[it.local_id].clone().substitute(Interner, &substs)

- });

- // Field type might have some unknown types

- // FIXME: we may want to emit a single type variable for all instance of type fields?

- let field_ty = self.insert_type_vars(field_ty);

- self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));

- let lhs_ty = self.infer_expr(lhs, &Expectation::none());

- static_lifetime, Interner, Scalar, Substitution, Ty, TyBuilder, TyExt, TyKind,

- let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();

- let (pre, post) = match ellipsis {

- Some(idx) => subs.split_at(idx),

- None => (subs, &[][..]),

- };

- let post_idx_offset = field_tys.iter().count().saturating_sub(post.len());

-

- let pre_iter = pre.iter().enumerate();

- let post_iter = (post_idx_offset..).zip(post.iter());

- for (i, &subpat) in pre_iter.chain(post_iter) {

- let expected_ty = var_data

- .as_ref()

- .and_then(|d| d.field(&Name::new_tuple_field(i)))

- .map_or(self.err_ty(), |field| {

- field_tys[field].clone().substitute(Interner, &substs)

- });

- let expected_ty = self.normalize_associated_types_in(expected_ty);

- T::infer(self, subpat, &expected_ty, default_bm);

- subs: impl Iterator<Item = (Name, T)>,

- let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();

- let var_data = def.map(|it| it.variant_data(self.db.upcast()));

- for (name, inner) in subs {

- let expected_ty = var_data

- .as_ref()

- .and_then(|it| it.field(&name))

- .map_or(self.err_ty(), |f| field_tys[f].clone().substitute(Interner, &substs));

- let expected_ty = self.normalize_associated_types_in(expected_ty);

- T::infer(self, inner, &expected_ty, default_bm);

- assert!(remaining_index < path.segments().len());

- let resolved_segment = path.segments().get(remaining_index - 1).unwrap();

- let remaining_segments = path.segments().skip(remaining_index);

- return Err(LayoutError::UserError(format!($it)))

- UserError(String),

- let FieldsShape::Array { count, .. } = db.layout_of_ty(f0_ty.clone(), env.clone())?.fields else {

- let count = try_const_usize(db, &count).ok_or(LayoutError::UserError(

- "unevaluated or mistyped const generic parameter".to_string(),

- ))? as u64;

- .to_string(),

- LayoutError::UserError("infinite sized recursive type".to_string()),

- LayoutError::UserError("infinite sized recursive type".to_string()),

-use std::{fmt::Display, iter};

- _ => {

- never!("Only adt has field");

- pub projection: Box<[PlaceElem]>,

- fn is_parent(&self, child: &Place) -> bool {

- self.local == child.local && child.projection.starts_with(&self.projection)

- fn iterate_over_parents(&self) -> impl Iterator<Item = Place> + '_ {

- (0..self.projection.len())

- .map(|x| &self.projection[0..x])

- .map(|x| Place { local: self.local, projection: x.to_vec().into() })

- fn project(&self, projection: PlaceElem) -> Place {

- Place {

- local: self.local,

- projection: self.projection.iter().cloned().chain([projection]).collect(),

- }

- Self { local, projection: vec![].into() }

- fn walk_places(&mut self, mut f: impl FnMut(&mut Place)) {

- fn for_operand(op: &mut Operand, f: &mut impl FnMut(&mut Place)) {

- f(p);

- f(p);

- | Rvalue::Use(o) => for_operand(o, &mut f),

- | Rvalue::Ref(_, p) => f(p),

- for_operand(o1, &mut f);

- for_operand(o2, &mut f);

- for_operand(op, &mut f);

- StatementKind::Deinit(p) => f(p),

- TerminatorKind::SwitchInt { discr, .. } => for_operand(discr, &mut f),

- f(place);

- f(place);

- for_operand(value, &mut f);

- for_operand(func, &mut f);

- args.iter_mut().for_each(|x| for_operand(x, &mut f));

- f(destination);

- for_operand(cond, &mut f);

- for_operand(value, &mut f);

- f(resume_arg);

-) -> Box<dyn Iterator<Item = Result<Arc<MirBody>, MirLowerError>> + '_> {

- ) -> Box<dyn Iterator<Item = Result<Arc<MirBody>, MirLowerError>> + '_> {

- let closures = body.closures.clone();

- Box::new(

- iter::once(Ok(body))

- .chain(closures.into_iter().flat_map(|it| for_closure(db, it))),

- )

- Err(e) => Box::new(iter::once(Err(e))),

- let closures = body.closures.clone();

- Box::new(

- iter::once(Ok(body)).chain(closures.into_iter().flat_map(|it| for_closure(db, it))),

- )

- Err(e) => Box::new(iter::once(Err(e))),

- let r = all_mir_bodies(db, def)

- .map(|body| {

- let body = body?;

- Ok(BorrowckResult {

- mutability_of_locals: mutability_of_locals(db, &body),

- moved_out_of_ref: moved_out_of_ref(db, &body),

- mir_body: body,

- })

- })

- .collect::<Result<Vec<_>, MirLowerError>>()?;

- Ok(r.into())

- for proj in &*p.projection {

- for proj in lvalue.projection.iter() {

- if p.projection.len() == 0 && p.local == l {

- let targets = match &terminator.kind {

- TerminatorKind::Goto { target } => vec![*target],

- TerminatorKind::SwitchInt { targets, .. } => targets.all_targets().to_vec(),

- | TerminatorKind::Unreachable => vec![],

- if destination.projection.len() == 0 && destination.local == l {

- target.into_iter().chain(cleanup.into_iter()).copied().collect()

- Some(target).into_iter().chain(unwind.into_iter()).copied().collect()

- vec![]

- }

- };

- for target in targets {

- if !result[target].contains_idx(l) || !result[target][l] && is_ever_initialized {

- result[target].insert(l, is_ever_initialized);

- dfs(db, body, target, l, result);

- if destination.projection.len() == 0 {

- MirSpan, Operand, Place, PlaceElem, ProjectionElem, Rvalue, StatementKind, TerminatorKind,

- UnOp,

- // FIXME: this could be more efficient

- let bytes = &interval.get(memory)?.to_vec();

- memory.write_memory(self.addr, bytes)

- BrokenLayout(Layout),

- MirLowerError::ConstEvalError(name.clone(), err.clone()).pretty_print(

- fn add_place(&mut self, p: Place) {

- if p.iterate_over_parents().any(|it| self.need_drop.contains(&it)) {

- self.need_drop.retain(|it| !p.is_parent(it));

- fn remove_place(&mut self, p: &Place) -> bool {

- if let Some(parent) = p.iterate_over_parents().find(|it| self.need_drop.contains(&it)) {

- for proj in &*p.projection {

- locals.drop_flags.add_place(l.clone());

- locals.drop_flags.add_place(destination.clone());

- locals.drop_flags.add_place(l.into());

- None => return Err(MirEvalError::BrokenLayout(variant_layout.clone())),

- None => return Err(MirEvalError::BrokenLayout(variant_layout.clone())),

- locals.drop_flags.remove_place(p);

- if !locals.drop_flags.remove_place(place) {

-use hir_def::resolver::HasResolver;

- let resolver = self.db.crate_def_map(self.crate_id).crate_root().resolver(self.db.upcast());

- &hir_def::path::Path::from_known_path_with_no_generic(ModPath::from_segments(

- hir_expand::mod_path::PathKind::Abs,

- [name![std], name![fmt], name![format]].into_iter(),

- )),

- let hir_def::resolver::ValueNs::FunctionId(format_fn) = format_fn else { not_supported!("std::fmt::format is not a function") };

- let message_string = self.interpret_mir(self.db.mir_body(format_fn.into()).map_err(|e| MirEvalError::MirLowerError(format_fn, e))?, args.map(|x| IntervalOrOwned::Owned(x.clone())))?;

- let addr = Address::from_bytes(&message_string[self.ptr_size()..2 * self.ptr_size()])?;

- Ok(std::string::String::from_utf8_lossy(self.read_memory(addr, size)?).into_owned())

- return Err(MirEvalError::TypeError(

- "syscall arg1 is not provided",

- ));

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner)) else {

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner)) else {

- return Err(MirEvalError::TypeError("min_align_of_val generic arg is not provided"));

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- return Err(MirEvalError::TypeError("ptr_offset_from generic arg is not provided"));

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- else {

- return Err(MirEvalError::TypeError("offset generic arg is not provided"));

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- let Some(ty) = generic_args.as_slice(Interner).get(0).and_then(|it| it.ty(Interner))

- return Err(MirEvalError::TypeError(

- "write_bytes generic arg is not provided",

- ));

- let Some(ty) = subst.as_slice(Interner).get(0).and_then(|it| it.ty(Interner)) else {

- ConstEvalError(String, Box<ConstEvalError>),

- /// This should be never happen. Type mismatch should catch everything.

- self.push_assignment(