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.5.3-1.3c 求值表达式的类型检查

求值表达式是指程序中进行求值运算的代码块,例如算术运算、函数调用、访问数组或对象属性、类型转换等。

求值表达式并不是一个特别严格、准确的术语,这里使用只是为了区分类型表达式,从最抽象的层面上来看,程序可以分为控制语句与计算单元,控制语句通过关键字来实现,例如 for, if 等用来控制程序的执行流,而 type, func 等用来告诉编译器需要创建新的类型;计算单元则用来达成程序的业务目的,这里所说的求值表达式属于计算单元,但也并不是所有的计算单元都会产生一个明确的返回值,例如一个函数可能没有返回值,调用函数只是为了该函数的副作用(Side effect)。当然有的语言为了使文法更加规范,使用一个特殊的值(void)来表示“没有值”。

对于求值表达式,类型检查器除了进行类型检查之外,还会尝试着对其求值,例如表达式"Hello, " + "Golang",运算符号+的两个运算符都是常量,所以在类型检查的过程中就会完成字符串的拼接操作,从而得到最终结果"Hello, Golang" 。类型检查器会尽可能得对表达式进行求值,以便提升程序在运行时的效率。

对求值表达式进行类型检查的入口是方法check.expr(), 核心逻辑封装在方法check.exprInternal()内,定义在文件$GCROOT/compile/internal/types2/expr.go中。 check.exprInternal()是一个 700 行代码的胖方法,但其基本的处理思路与check.typInternal()是一样的,都是通过 switch...case... 语句根据表达式的类型进行递归检查,我们贴出部分代码一探究竟:

func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKind {
	switch e := e.(type) {
	case *syntax.Name:
		// 对标识符进行类型检查,如果该标识符已经完成了类型检查,则递归终止,否则递归进行检查
		check.ident(x, e, nil, false)
	case *syntax.BasicLit:
		// 基本类型都是常量表达式,设置常量值。
		x.setConst(e.Kind, e.Value)
	case *syntax.FuncLit:
		// 函数字面量是形如 func() {} 的表达式,先对函数类型进行检查,再将函数体的检查推入 delayed 队列
		if sig, ok := check.typ(e.Type).(*Signature); ok {
			decl := check.decl
			iota := check.iota
			check.later(func() {
				check.funcBody(decl, "<function literal>", sig, e.Body, iota)
			})
			x.mode = value
			x.typ = sig
		}
	}
}

这里删除了绝大多数代码,只保留了三个 case 的部分代码来帮助我们理解该方法的处理思路。其中syntax.Name与syntax.BasicLit是该函数递归的 base-case, 而syntax.FuncLit则体现了对符合表达式的分解,并且可以发现对函数体的类型检查被推入了 delayed 队列,这在后续会有介绍。

对求值表达式的检查结果放在结构体operand中,其定义如下:

type operand struct {
	mode operandMode
	expr syntax.Expr
	typ  Type
	val  constant.Value
	id   builtinId
}

该结构用来保存类型检查的中间值,属性typ与val分别用来保存推导出来的类型以及计算出来的值。

上一页4.5.3-1.3b 类型表达式的类型检查下一页4.5.3-1.3d 类型兼容性检查

最后更新于3年前

这有帮助吗?