Golang 编译器代码浅析
  • 0. Golang 编译器代码浅析
  • 1. golang 编译器 - 前言
    • 1.1 编译器简介
    • 1.2 Golang 编译器
    • 1.3 Go 语言版本
    • 1.4 项目设置
    • 1.5 约定
    • 1.6 写作目的
  • 2. golang 编译器 - 词法分析
    • 2.1 简介
    • 2.2 代码结构
    • 2.3 处理字符
    • 2.4 扫描Token
    • 2.5 总结
  • 3.a 语法分析理论知识
    • 3A.1 语法分析简介
    • 3A.2 文法
    • 3A.3 语法解析
    • 3A.3.1 自顶向下(Top-Down)
    • 3A.3.2 自顶向下 - 递归下降
    • 3A.3.3 自顶向下 - LL(1)文法
    • 3A.3.4 自底向上(Bottom-Up)
    • 3A.3.5 自底向上 - LR(0)项集及SLR预测表
    • 3A.3.6 自底向上 - LR(1)、LALR
    • 3A.4 语法分析工具
    • 3A.5 总结
  • 3B. golang 编译器 - 语法分析
    • 3B.1 简介
    • 3B.2 代码结构
    • 3B.3 数据结构
    • 3B.4 构造语法树
    • 3B.5 Unit Test及AST可视化
  • 4. Golang 编译器 - 类型检查
    • 4.1 简介
    • 4.2 代码结构
    • 4.3 符号解析
    • 4.4.1 数据结构 - 作用域
    • 4.4.2 数据结构 - Package
    • 4.4.3 数据结构 - Object 对象
    • 4.4.4-1 类型数据结构 - 简介
    • 4.4.4-2 类型接口
    • 4.4.4-3 基础类型
    • 4.4.4-4 内置复合类型
    • 4.4.4-5 Struct 类型
    • 4.4.4-6 Interface 类型
    • 4.4.4-7 Named 类型
    • 4.4.4-8 Tuple 类型
    • 4.4.4-9 Sum 类型
    • 4.4.4-10 Function & Method 类型
    • 4.4.4-11 泛型类型
    • 4.4.4-12 类型的等价规则
    • 4.4.4-13 类型的比较规则
    • 4.4.4-14 总结
    • 4.4.5 类型检查器
    • 4.4.6 总结
    • 4.5.1 类型检查逻辑 - 包加载器
    • 4.5.2 类型检查逻辑 - 初始化
    • 4.5.2-1 全局作用域
    • 4.5.2-2 类型检查器
    • 4.5.3 类型检查逻辑 - 流程分析
    • 4.5.3-1.1 总体流程
    • 4.5.3-1.2 类型检查准备工作
    • 4.5.3-1.3 类型检查核心逻辑
    • 4.5.3-1.3a 总体介绍
    • 4.5.3-1.3b 类型表达式的类型检查
    • 4.5.3-1.3c 求值表达式的类型检查
    • 4.5.3-1.3d 类型兼容性检查
    • 4.5.3-1.3e 处理delayed队列
    • 4.5.3-1.4 构建初始化顺序
    • 4.5.3-1.5 总结
    • 4.5.3-2 特定问题分析
    • 4.5.3-2a 对象循环依赖检查
    • 4.5.3-2b 方法与属性查找
    • 4.5.3-2c Underlying Type
    • 4.6 如何测试
    • 4.7 总结
  • 5. Golang 编译器 - IR Tree
    • 5.1 简介
    • 5.2 代码结构
    • 5.3 数据结构
    • 5.4 处理逻辑
    • 5.5 编译日志
    • 5.6 Unit Test
    • 5.7 总结
  • 6. golang 编译器 - 初始化任务
    • 6.1 简介
    • 6.2 代码结构
    • 6.3 总体逻辑
    • 6.4 赋值语句
    • 6.5 编译日志
    • 6.6 Unit Test
    • 6.7 总结
  • 7. golang 编译器 - 清除无效代码
    • 7.1 简介
    • 7.2 处理逻辑
    • 7.3 Unit Test
  • 8. golang 编译器 - Inline
    • 8.1 简介
    • 8.2 Inline的问题
    • 8.3 代码结构
    • 8.4 处理逻辑
    • 8.4.1 遍历调用链
    • 8.4.2 内联判断
    • 8.4.3 内联操作
    • 8.4.4 编译日志
    • 8.4.5 Unit Test
    • 8.4.6 总结
  • 9. golang 编译器 - 逃逸分析
    • 9.1 什么是逃逸分析
    • 9.2 Go 的逃逸分析
    • 9.3 算法思路
    • 9.4 代码结构
    • 9.5 处理逻辑
    • 9.5.1总体逻辑
    • 9.5.2 数据结构
    • 9.5.3 构建数据流有向图
    • 9.5.4 逃逸分析
    • 9.6 编译日志
    • 9.7 Unit Test
    • 9.8 总结
  • 10. golang 编译器 - 函数编译及导出
    • 10.1 简介
    • 10.2 编译函数
    • 10.2.1 SSA
    • 10.2.2 ABI
    • 10.2.3 并发控制
    • 10.3 导出对象文件
    • 10.4 总结
  • 11. Golang 编译器 - 写在最后
由 GitBook 提供支持
在本页

这有帮助吗?

  1. 4. Golang 编译器 - 类型检查

4.4.4-11 泛型类型

函数与类型中申明的泛型使用如下数据结构来表示:

type TypeParam struct {
    check *Checker  // for lazy type bound completion
    id    uint64    // unique id
    obj   *TypeName // 
    index int       // parameter index
    bound Type      // *Named or *Interface; underlying type is always *Interface
}

除此之外还有三个类型用于泛型,其定义如下:

type instance struct {
    check   *Checker     // for lazy instantiation
    pos     syntax.Pos   // position of type instantiation; for error reporting only
    base    *Named       // parameterized type to be instantiated
    targs   []Type       // type arguments
    poslist []syntax.Pos // position of each targ; for error reporting only
    value   Type         // base(targs...) after instantiation or Typ[Invalid]; nil if not yet set
}
type bottom struct{}
type top struct{}

bottom 与 top 是两个标记类型。当接口中包含泛型的 constraints 时,我们需要推算出当前接口中 constraints 所包含的实际类型,例如如下申明:

type SmallInt interface {
    type int8, int16, int32
}

type BigInt interface {
    type int, int32, int64
}

type MediumInt interface {
    SmallInt
    BigInt
    type int16, int32
}

MediumInt 中除了申明了自己的 constraints 列表, 还内嵌了 SmallInt 与 BigInt, 此时 MediumInt 的实际 constraints 自然应该是三者的并集:int32. bottom 与 top 两个类型用于表示两个特殊的集合:前者表示空集,后者表示全集。

instance 代表一个实例化了的泛型,泛型也叫类型参数(type parameter),我们先来回顾一下普通的函数参数:

func sum(i, j int) int {
    return i + j
}

但凡说道“参数”,就需要使用者将具体的实参传递进去。i, j 是函数 sum 的形参,我们可以将函数看着是一个计算模版,当调用者提供该模版的实参时,我们就可以通过该“模版”计算出最终值。那么“类型参数”该如何传递呢?我们先来看一个典型的泛型定义:

type Node[T comparable] struct {
    val T
}

Node 是我们定义的一个类型,但是该类型并不完备:属性 val 的类型 T 还是未知的,由使用者提供。我们可以将 T 看着是 Node 的类型参数,从而将将 Node[T comparable] 看着是一个类型模版,当使用者提供具体的参数类型时,我们就可以得到一个具体的Node类型。例如当 T 为 int32 时,我们得到具体类型是:

type Node struct {
    val int32
}

该过程叫着类型的实例化。所以在代码中,任何使用泛型 Node 的地方都需要传入类型参数,例如如下代码:

// 该方法中一共有三个实例化的 Node 类型:Node[string], Node[float32] 与 Node[int32]
func convert(nod Node[string]) Node[float32] {   
var _ Node[int32]
}

go 编译器内部使用 instance 来表示一个实例化的泛型类型,其中 base 是“类型模版”,而 targs 就是具体传入的参数类型值。例如上述代码中将会生成三个具体类型,对应三个 instance 实例。

上一页4.4.4-10 Function & Method 类型下一页4.4.4-12 类型的等价规则

最后更新于3年前

这有帮助吗?

事实上,编译器在 时便会为所有泛型函数做实例化。

生成 IR Tree