standard library made a utility for itself called `Unique<T>` which:  Here’s a table of all the wonderful ways `PhantomData` could be used: -| Phantom type                | `'a`      | `T`                       |-|-----------------------------|-----------|---------------------------|-| `PhantomData<T>`            | -         | covariant (with drop check) |-| `PhantomData<&'a T>`        | covariant | covariant                 |-| `PhantomData<&'a mut T>`    | covariant | invariant                 |-| `PhantomData<*const T>`     | -         | covariant                 |-| `PhantomData<*mut T>`       | -         | invariant                 |-| `PhantomData<fn(T)>`        | -         | contravariant             |-| `PhantomData<fn() -> T>`    | -         | covariant                 |-| `PhantomData<fn(T) -> T>`   | -         | invariant                 |-| `PhantomData<Cell<&'a ()>>` | invariant | -                         |+| Phantom type                | `'a`      | `T`                         | `Send`    | `Sync`    |+|-----------------------------|-----------|-----------------------------|-----------|-----------|+| `PhantomData<T>`            | -         | covariant (with drop check) | `T: Send` | `T: Sync` |+| `PhantomData<&'a T>`        | covariant | covariant                   | `T: Send` | `T: Sync` |

  #include "rust-expand-visitor.h" #include "rust-attributes.h"+#include "rust-ast.h"+#include "rust-type.h"+#include "rust-derive.h"  namespace Rust { +bool+is_derive (AST::Attribute &attr)+{+  auto path = attr.get_path ();+  return attr.has_attr_input ()+	 && attr.get_attr_input ().get_attr_input_type ()+	      == AST::AttrInput::TOKEN_TREE+	 && path == "derive";+}++bool+is_builtin (AST::Attribute &attr)+{+  auto &segments = attr.get_path ().get_segments ();+  return !segments.empty ()+	 && !Analysis::BuiltinAttributeMappings::get ()+	       ->lookup_builtin (segments[0].get_segment_name ())+	       .is_error ();+}+ /* Expand all of the macro invocations currently contained in a crate */ void ExpandVisitor::go (AST::Crate &crate)+{+  expand_inner_items (crate.items);+}++/**+ * Returns a list of all the derive macros to apply, as well as the Attribute+ * they are from.+ *+ * ```rust+ * #[derive(Clone, Copy)] // attr1+ * struct S;+ *+ * // returns [{Clone, &attr1}, {Copy, &attr1}]+ *+ * #[derive(Clone)] // attr1+ * #[derive(Copy, PartialEq, Ord)] // attr2+ * struct S;+ *+ * // returns [{Clone, &attr1}, {Copy, &attr2}, {PartialEq, &attr2}, {Ord,+ * &attr2}]+ * ```+ *+ * @param outer_attrs The list of attributes on the item to derive+ */+static std::vector<+  std::pair<std::string, std::reference_wrapper<const AST::Attribute>>>+get_traits_to_derive (std::vector<AST::Attribute> &outer_attrs)+{+  std::vector<+    std::pair<std::string, std::reference_wrapper<const AST::Attribute>>>+    to_derive;+  for (auto it = outer_attrs.begin (); it != outer_attrs.end ();)+    {+      auto &attr = *it;++      if (is_derive (attr))+	{+	  auto &input = attr.get_attr_input ();+	  switch (input.get_attr_input_type ())+	    {+	      // isn't there a better way to do this?? like parse it or+	      // something idk. some function I'm not thinking of?+	      case AST::AttrInput::TOKEN_TREE: {+		auto &tokens = static_cast<AST::DelimTokenTree &> (input)+				 .get_token_trees ();++		// erase the delimiters+		rust_assert (tokens.size () >= 3);+		tokens.erase (tokens.begin ());+		tokens.pop_back ();++		for (auto &token : tokens)+		  {+		    // skip commas, as they are part of the token stream+		    if (token->as_string () == ",")+		      continue;++		    to_derive.emplace_back (token->as_string (), attr);

+// Copyright (C) 2020-2023 Free Software Foundation, Inc.++// This file is part of GCC.++// GCC is free software; you can redistribute it and/or modify it under+// the terms of the GNU General Public License as published by the Free+// Software Foundation; either version 3, or (at your option) any later+// version.++// GCC is distributed in the hope that it will be useful, but WITHOUT ANY+// WARRANTY; without even the implied warranty of MERCHANTABILITY or+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License+// for more details.++// You should have received a copy of the GNU General Public License+// along with GCC; see the file COPYING3.  If not see+// <http://www.gnu.org/licenses/>.++#include "rust-derive-clone.h"++namespace Rust {+namespace AST {++std::unique_ptr<Expr>+DeriveClone::clone_call (std::unique_ptr<Expr> &&to_clone)+{+  // $crate::core::clone::Clone::clone for the fully qualified path - we don't+  // link with `core` yet so that might be an issue. Use `Clone::clone` for now?+  // TODO: `has_opening_scope_resolution`? Does it have it?

 Mappings::insert_macro_def (AST::MacroRulesDefinition *macro) 		   });   if (should_be_builtin)     {-      auto builtin-	= MacroBuiltin::builtin_transcribers.find (macro->get_rule_name ());-      if (builtin != MacroBuiltin::builtin_transcribers.end ())-	macro->set_builtin_transcriber (builtin->second);-      else+      auto builtin = MacroBuiltin::builtins.lookup (macro->get_rule_name ());+      if (!MacroBuiltin::builtins.is_iter_ok (builtin)) 	rust_error_at (macro->get_locus (), 		       "cannot find a built-in macro with name %qs", 		       macro->get_rule_name ().c_str ());+      return;

 impl<'a, 'tcx> Builder<'a, 'tcx> {         let category = Category::of(&expr.kind).unwrap();         debug!(?category, ?expr.kind);         match category {-            Category::Constant if let NeedsTemporary::No = needs_temporary || !expr.ty.needs_drop(this.tcx, this.param_env) => {