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.3d 类型兼容性检查

类型的期望类型与实际类型是否兼容,是类型兼容性检查的核心,例如赋值语句var name string = getName();中,name 的期望类型是 string, 因此函数 getName() 的返回值必须也是 string, 类型检查器需要对此进行核实。

程序很多地方都会涉及到类型兼容性问题,例如赋值、函数定义、channel 写入等等,该问题的核心到最后往往体现为“能否将一个值赋给指定类型”,判断的核心逻辑定义在文件$GCROOT/compile/internal/types2/assignments.go中,入口函数是check.assignment(), 抛开细节,其主体逻辑如下:

// x 是赋值语句的右值,而 T 是赋值语句左边的目标类型,context 用来记录上下文信息,例如 "return statement", 便于提示错误信息
func (check *Checker) assignment(x *operand, T Type, context string) {
	if isUntyped(x.typ) {
		// 处理 x 是 UntypedXXX 的情况,尝试将 x.val 的值转换给类型 T
		check.convertUntyped(x, target)
	}
	if reason := ""; !x.assignableTo(check, T, &reason) {
		// 判断 x 能够赋值给类型 T, 此处删除错误处理信息
	}
}

assignableTo()方法定义在文件$GCROOT/compile/internal/types2/operand.go中,删掉细节代码,其主体逻辑如下:

func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
	V := x.typ
	if check.identical(V, T) { // x 的类型与目标类型等价,则可以赋值
		return true
	}

	Vu := optype(V) // 拿到运算符的 underlying type
	Tu := optype(T) // 拿到目标类型的 underlying type

	// 处理 x 是常量值的情况
	if isUntyped(Vu) {
		switch t := Tu.(type) {
		case *Basic:
			// 目标类型是基础类型,此处判断 x 是否能够表示为该基础类型
		case *Sum:
			// 如果 x 可以赋值给 Sum 类型所带表的所有类型,则返回 true
			return t.is(func(t Type) bool {
				return x.assignableTo(check, t, reason)
			})
		case *Interface:
			check.completeInterface(nopos, t)
			return x.isNil() || t.Empty() // 如果 T 是 interface, 此时因为 x 是基础类型。那么只有当 x 是 nil, 或者 T 是 interface{} 时,x 才可以赋值给 T
		case *Pointer, *Signature, *Slice, *Map, *Chan:
			return x.isNil() // nil 可以赋值给指针、函数、切片、Map 以及 chan 类型
		}
	}

	/*
	 * 如果两个类型的 underlying type 是等价的,那么只要两个类型不同时是 defined type, 就可以进行赋值
	 * 详见 underlying type 一节的讨论
	 */
	if check.identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
		return true
	}

	// 如果 T 是 interface, 则判断 x 是否实现了该接口
	if Ti, ok := Tu.(*Interface); ok {
		// 判断类型 V 是否实现接口 Ti 的方式是检查 V 的方法集合是否覆盖了 Ti 的所有方法
		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ {
			// 找到缺失方法,进行错误处理
			return false
		}
		return true
	}

	// 判断两个 channel 类型是否可以赋值
	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
		if Tc, ok := Tu.(*Chan); ok && check.identical(Vc.elem, Tc.elem) {
			return !isNamed(V) || !isNamed(T)
		}
	}

	return false
}
上一页4.5.3-1.3c 求值表达式的类型检查下一页4.5.3-1.3e 处理delayed队列

最后更新于3年前

这有帮助吗?

这两个方法是兼容性检查的主体思路,check.identical()我们已经在中讨论过,UntypedXXX 的转换规则也已经在中讨论过,后续章节会详细讨论 Underlying Type 的赋值规则,以及如何判断一个类型是否实现了某个接口。

类型的等价规则
基础类型的Untyped 部分