//称为GenTypeA的泛化类型的定义，泛化部分为<T>，T可为任意一个类型；
struct GenTypeA<T> {
  data: T, // data为类型为T的成员；
}

//称为GenTypeB的泛化类型的定义，泛化部分为<'a, T>，其中包含生命周期'a和可为任意类型的T；
struct GenTypeB<'a, T> {
  data: &'a T,
}

//GenTypeA<T>作为函数的参数a的类型来使用
fn gen_fn<T>(a: GenTypeA<T>) ->() {}

//使用GenTypeA泛化类型名称来定义和初始化变量a，
//变量a的类型推导后为GenTypeA<i8>
let a = GenTypeA { data: 0 };

//使用GenTypeA泛化类型全路径名称来定义和初始化变量a，
//变量a的类型为GenTypeA<i8>
let aa = GenTypeA::<i8> { data: 0 };

let b = 0;
//使用GenTypeB泛化类型名称来定义和初始化变量c，
//变量c的类型推导后为GenTypeB<'a, i8>
let c = GenTypeB { data: &b };
let cc = GenTypeB::<i8> { data: &b };
let ccc = GenTypeB::<'a, i8> { data: &b };

gen_fn(a);
gen_fn(aa);

struct GenTypeC<T: Display + Send> {
    data: T,
}

fn printer<T: Display>(t: T) {
    println!("{}", t);
}

//src/librustc_hir/hir.rs
pub struct Ty<'hir> {
    pub hir_id: HirId,
    pub kind: TyKind<'hir>,
    pub span: Span,
}

pub enum TyKind<'hir> {
    /// A variable length slice (i.e., `[T]`).
    Slice(&'hir Ty<'hir>),
    /// A fixed length array (i.e., `[T; n]`).
    Array(&'hir Ty<'hir>, AnonConst),
    /// A raw pointer (i.e., `*const T` or `*mut T`).
    Ptr(MutTy<'hir>),
    /// A reference (i.e., `&'a T` or `&'a mut T`).
    Rptr(Lifetime, MutTy<'hir>),
    /// A bare function (e.g., `fn(usize) -> bool`).
    BareFn(&'hir BareFnTy<'hir>),
    /// The never type (`!`).
    Never,
    /// A tuple (`(A, B, C, D, ...)`).
    Tup(&'hir [Ty<'hir>]),
    /// A path to a type definition (`module::module::...::Type`),
    /// or an associated type (e.g., `<Vec<T> as Trait>::Type`
    /// or `<T>::Target`).
    /// Type parameters may be stored in each `PathSegment`.
    Path(QPath<'hir>),
    /// A opaque type definition itself. This is currently only
    /// used for the `opaque type Foo: Trait` item that `impl Trait`.
    OpaqueDef(ItemId, &'hir [GenericArg<'hir>]),
    /// A trait object type `Bound1 + Bound2 + Bound3`
    /// where `Bound` is a trait or a lifetime.
    TraitObject(&'hir [PolyTraitRef<'hir>], Lifetime),
    /// Unused for now.
    Typeof(AnonConst),
    /// `TyKind::Infer` means the type should be inferred.
    Infer,
    /// Placeholder for a type that has failed to be defined.
    Err,
}

/// src/librustc_middle/ty/mod.rs
pub type Ty<'tcx> = &'tcx TyS<'tcx>;

pub struct TyS<'tcx> {
    kind: TyKind<'tcx>,
    flags: TypeFlags,
    outer_exclusive_binder: ty::DebruijnIndex,
}

pub enum TyKind<'tcx> {
    /// The primitive boolean type. Written as `bool`.
    Bool,
    /// The primitive character type; holds a Unicode scalar value
    /// Written as `char`.
    Char,
    /// A primitive signed integer type. For example, `i32`.
    Int(ty::IntTy),
    /// A primitive unsigned integer type. For example, `u32`.
    Uint(ty::UintTy),
    /// A primitive floating-point type. For example, `f64`.
    Float(ty::FloatTy),

    /// Algebraic data types (ADT).
    /// For example: structures, enumerations and unions.
    Adt(&'tcx AdtDef, SubstsRef<'tcx>),

    /// An unsized FFI type that is opaque to Rust.
    /// Written as `extern type T`.
    Foreign(DefId),

    /// The pointee of a string slice. Written as `str`.
    Str,

    /// An array with the given length. Written as `[T; n]`.
    Array(Ty<'tcx>, &'tcx ty::Const<'tcx>),

    /// The pointee of an array slice. Written as `[T]`.
    Slice(Ty<'tcx>),

    /// A raw pointer. Written as `*mut T` or `*const T`
    RawPtr(TypeAndMut<'tcx>),

    /// A reference; a pointer with an associated lifetime.
    /// Written as `&'a mut T` or `&'a T`.
    Ref(Region<'tcx>, Ty<'tcx>, hir::Mutability),

    /// The anonymous type of a function declaration/definition.
    /// Each function has a unique type, which is output 
    /// (for a function named `foo` returning an `i32`)
    /// as `fn() -> i32 {foo}`.
    ///
    /// For example the type of `bar` here:
    ///
    /// ```rust
    /// fn foo() -> i32 { 1 }
    /// let bar = foo; // bar: fn() -> i32 {foo}
    /// ```
    FnDef(DefId, SubstsRef<'tcx>),

    /// A pointer to a function.
    /// Written as `fn() -> i32`.
    /// For example the type of `bar` here:
    ///
    /// ```rust
    /// fn foo() -> i32 { 1 }
    /// let bar: fn() -> i32 = foo;
    /// ```
    FnPtr(PolyFnSig<'tcx>),

    /// A trait object.
    /// Written as `dyn for<'b> Trait<'b, Assoc = u32> + Send + 'a`.
    Dynamic(&'tcx List<Binder<'tcx, ExistentialPredicate<'tcx>>>
      , ty::Region<'tcx>),

    /// The anonymous type of a closure.
    /// Used to represent the type of `|a| a`.
    Closure(DefId, SubstsRef<'tcx>),

    /// The anonymous type of a generator.
    /// Used to represent the type of `|a| yield a`.
    Generator(DefId, SubstsRef<'tcx>, hir::Movability),

    /// A type representing the types stored inside a generator.
    /// This should only appear in GeneratorInteriors.
    GeneratorWitness(Binder<'tcx, &'tcx List<Ty<'tcx>>>),

    /// The never type `!`.
    Never,

    /// A tuple type. For example, `(i32, bool)`.
    /// Use `TyS::tuple_fields` to iterate over the field types.
    Tuple(SubstsRef<'tcx>),

    /// The projection of an associated type. For example,
    /// `<T as Trait<..>>::N`.
    Projection(ProjectionTy<'tcx>),

    /// Opaque (`impl Trait`) type found in a return type.
    /// The `DefId` comes either from
    /// * the `impl Trait` ast::Ty node,
    /// After typeck, the concrete type can be found in the `types` map.
    Opaque(DefId, SubstsRef<'tcx>),

    /// A type parameter; for example, `T` in `fn f<T>(x: T) {}`.
    Param(ParamTy),

    /// Bound type variable, used only when preparing a trait query.
    Bound(ty::DebruijnIndex, BoundTy),

    /// A placeholder type - universally quantified higher-ranked type.
    Placeholder(ty::PlaceholderType),

    /// A type variable used during type checking.
    Infer(InferTy),

    /// A placeholder for a type which could not be computed;
    Error(DelaySpanBugEmitted),
}

pub struct AdtDef {
    /// The `DefId` of the struct, enum or union item.
    pub did: DefId,
    /// Variants of the ADT.
    /// If this is a struct or union, then there will be a single variant.
    pub variants: IndexVec<VariantIdx, VariantDef>,
    /// Flags of the ADT (e.g., is this a struct?).
    flags: AdtFlags,
    /// Repr options provided by the user.
    pub repr: ReprOptions,
}

pub struct VariantDef {
    /// `DefId` that identifies the variant itself.
    pub def_id: DefId,
    /// `DefId` that identifies the variant's constructor.
    pub ctor_def_id: Option<DefId>,
    /// Variant or struct name.
    #[stable_hasher(project(name))]
    pub ident: Ident,
    /// Discriminant of this variant.
    pub discr: VariantDiscr,
    /// Fields of this variant.
    pub fields: Vec<FieldDef>,
    /// Type of constructor of variant.
    pub ctor_kind: CtorKind,
    flags: VariantFlags,
    pub recovered: bool,
}

pub struct FieldDef {
    pub did: DefId,
    pub ident: Ident,
    pub vis: Visibility,
}

pub type SubstsRef<'tcx> = &'tcx InternalSubsts<'tcx>;

pub type InternalSubsts<'tcx> = List<GenericArg<'tcx>>;

pub struct GenericArg<'tcx> {
    ptr: NonZeroUsize,
    marker: PhantomData<(Ty<'tcx>, ty::Region<'tcx>, 
      &'tcx ty::Const<'tcx>)>,
}

const TAG_MASK: usize = 0b11;
const TYPE_TAG: usize = 0b00;
const REGION_TAG: usize = 0b01;
const CONST_TAG: usize = 0b10;

pub enum GenericArgKind<'tcx> {
    Lifetime(ty::Region<'tcx>),
    Type(Ty<'tcx>),
    Const(&'tcx ty::Const<'tcx>),
}

struct Foo<A, B> { // Adt(Foo, &[Param(0), Param(1)])
  x: Vec<A>, // Adt(Vec, &[Param(0)])
  ..
}

fn bar(foo: Foo<u32, f32>) { // Adt(Foo, &[u32, f32])
  let y = foo.x; // Vec<Param(0)> => Vec<u32>
}

src/librustc_middle/ty/sty.rs
pub type Region<'tcx> = &'tcx RegionKind;

pub enum RegionKind {
    /// Region bound in a type or fn declaration 
    /// which will be substituted 'early'
    /// -- that is, at the same time when type
    /// parameters are substituted.
    /// 对应类似Arguments<'a>场景下的值
    ReEarlyBound(EarlyBoundRegion),

    /// Region bound in a function scope,
    /// which will be substituted when the function is called.
    /// 对应类似for<'a> fn(&'a u32)场景下的值
    ReLateBound(ty::DebruijnIndex, BoundRegion),

    /// When checking a function body, the types of all arguments 
    /// refer to free region parameters.
    /// 对应函数体内部引用函数参数中提供的region值
    ReFree(FreeRegion),

    /// Static data that has an "infinite" lifetime.
    /// 对应'static场景值
    ReStatic,

    /// A region variable.
    ReVar(RegionVid),

    /// A placeholder region
    /// --basically, the higher-ranked version of `ReFree`.
    /// 对应类似fn bar(f: for<'a> fn(&'a u32))场景下的值
    RePlaceholder(ty::PlaceholderRegion),

    /// Empty lifetime is for data that is never accessed.
    ReEmpty(ty::UniverseIndex),

    /// Erased region, 
    /// used by trait selection, in MIR and during codegen.
    /// 对应在代码生成阶段，Region值被清空
    ReErased,
}

// src/librustc_driver/lib.rs
pub fn run_compiler(
    at_args: &[String],
    callbacks: &mut (dyn Callbacks + Send),
    file_loader: Option<Box<dyn FileLoader + Send + Sync>>,
    emitter: Option<Box<dyn Write + Send>>,
) -> interface::Result<()> {
    // ..............................
    interface::run_compiler(config, |compiler| {
        let sess = compiler.session();
        let linker = compiler.enter(|queries| {
            //...............
            // 省略生成global_ctxt之前相关逻辑
            queries.global_ctxt()?;
            // .....................................
            // 调用anaylysis，它会对当前crate分析检查
            queries.global_ctxt()?.peek_mut().enter(
               |tcx| tcx.analysis(LOCAL_CRATE))?;
            // 查看分析结果是否正常，否则直接退出
            if callbacks.after_analysis(compiler, queries) 
               == Compilation::Stop {
                return early_exit();
            }
            // ..................
        }
    // ..................
}

// src/librustc_interface/passes.rs
/// Runs the resolution, type-checking, region checking and other
/// miscellaneous analysis passes on the crate.
fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
    assert_eq!(cnum, LOCAL_CRATE);
    // hir_id完整性检查
    rustc_passes::hir_id_validator::check_crate(tcx);

    let sess = tcx.sess;
    let mut entry_point = None;

    // 省略其他部分类型检查包括循环、属性、接口、入口函数检查
    // .....................

    // passes are timed inside typeck
    typeck::check_crate(tcx)?;

    // 省略其他部分类型检查包括MIR生成及借用检查
    // .....................

    Ok(())
}


src/librustc_typeck/lib.rs
pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> {
    let _prof_timer = tcx.sess.timer("type_check_crate");

    // this ensures that later parts of type checking can assume that items
    // have valid types and not error
    // FIXME(matthewjasper) We shouldn't need to do this.
    tcx.sess.track_errors(|| {
        tcx.sess.time("type_collecting", || {
            for &module in tcx.hir().krate().modules.keys() {
                tcx.ensure().collect_mod_item_types(tcx.hir().local_def_id(module));
            }
        });
    })?;
    //...............................
    // 省略其他部分检查
    // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync.
    tcx.sess.time("item_types_checking", || {
        for &module in tcx.hir().krate().modules.keys() {
            tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module));
        }
    });

    tcx.sess.time("item_bodies_checking", || tcx.typeck_item_bodies(LOCAL_CRATE));

    check_unused::check_crate(tcx);
    check_for_entry_fn(tcx);
    //...............................
    // 省略其他部分检查
}


src/librustc_typeck/collect.rs +217

fn collect_mod_item_types(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {
    // CollectItemTypesVisitor遍历hir::Crate中Item以生成ty::Ty
    tcx.hir().visit_item_likes_in_module(
        module_def_id,
        &mut CollectItemTypesVisitor { tcx }.as_deep_visitor(),
    );
}

src/librustc_typeck/check/mod.rs
fn typeck_item_bodies(tcx: TyCtxt<'_>, crate_num: CrateNum) {
    debug_assert!(crate_num == LOCAL_CRATE);
    tcx.par_body_owners(|body_owner_def_id| {
        tcx.ensure().typeck(body_owner_def_id);
    });
}

// librustc_typeck/check/mod.rs

fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
    if let Some(param_did) = tcx.opt_const_param_of(def_id) {
        tcx.typeck_const_arg((def_id, param_did))
    } else {
        let fallback = move || tcx.type_of(def_id.to_def_id());
        typeck_with_fallback(tcx, def_id, fallback)
    }
}

fn typeck_with_fallback<'tcx>(
    tcx: TyCtxt<'tcx>,
    def_id: LocalDefId,
    fallback: impl Fn() -> Ty<'tcx> + 'tcx,
) -> &'tcx ty::TypeckResults<'tcx> {
    
    // 省略部分其他代码
    let id = tcx.hir().local_def_id_to_hir_id(def_id);

    let body = tcx.hir().body(body_id);

    let typeck_results = Inherited::build(tcx, def_id).enter(|inh| {
           // 省略大部分代码
           // 创建FnCtx来维护Fn上下文，检查每一个表达式涉及的类型并保存下来
           // 省略大部分代码
        };
        // 省略大部分代码
        if fn_decl.is_some() {
            // 对涉及生命周期部分进行检查
            fcx.regionck_fn(id, body);
        } else {
            fcx.regionck_expr(body);
        }

        fcx.resolve_type_vars_in_body(body)
    });

    // Consistency check our TypeckResults instance
    // can hold all ItemLocalIds it will need to hold.
    assert_eq!(typeck_results.hir_owner, id.owner);

    typeck_results
}