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-2c Underlying Type

上一页4.5.3-2b 方法与属性查找下一页4.6 如何测试

最后更新于3年前

这有帮助吗?

的申明中包含Underlying() Type这个方法,而所有的类型中只有的 Underlying Type 与自身不一样,其余所有类型的该方法都是返回自身。

在中我们知道编译器在做类型检查时,所有的类型信息都是通过函数check.typ()创建的,那么程序中的哪些表达式会导致调用该函数呢?答案是真正声明了一个类型的表达式,下列例子都会申明一个类型:

int // 申明一个 int 类型
map[string]bool // 申明一个 map 类型
<- chan int // 申明一个 channel 类型
struct {/* 忽略 Fields */} // 申明一个 struct 类型
interface { /* 忽略方法申明 */ } // 申明一个 interface 类型

上面的每一行都会促使编译器创建一个类型,这种表达式叫着类型字面量(Type Literal),在中我们提到 Go 采用的是结构化类型系统,只要类型的结构一致,那么就是等价的,所以下列代码是合法的:

func f(s struct {
	name string
	age  int
})

func main() {
	f(struct {
		name string
		age  int
	}{"golang", 12})
}

如果只能够通过字面量的方式创建类型,那就太繁琐了:在每个需要类型的地方都必须将类型的结构重新申明一遍。解决该问题的办法是为字面量类型取一个名字,该任务由type关键字完成。因此我们可以将所有type的申明分为三个部分: type <name> <type literal>

  • type: 关键字,提醒编译器接下来进入类型申明的代码块

  • <name>: 类型名字

  • <type literal>: 实际的类型值,该值将与 <name> 绑定

这也是为何通过type关键字申明的类型叫Named的原因。而 <type literal> 所代表的实际类型,就是Named的 Underlying Type.

type A struct {
	name string
}

func (this *A) getName() string {
	return "A: " + this.name
}

type B A

// 可以为类型 B 定义与类型 A 一样的方法
func (this *B) getName() string {
	return "B: " + this.name
}

type C B

func TestABC(t *testing.T) {
	var c C = C{name: "golang"} // OK, C 的 underlying type 是 A, 也有 name 属性

	_ = c.name      // 可以引用 name 属性
	_ = c.getName() // Compile error: c.getName undefined (type C has no field or method getName) [MissingFieldOrMethod]
}
func under(t Type) Type {
	if n := asNamed(t); n != nil {
		return n.under()
	}
	return t
}

其中参数 t 是 decl 的类型,即如果 decl 是 Named 类型,则递归查找其 Underlying Type, 直到遇到非 Named 类型为止,则该类型就是整个链上所有 Named 类型的 Underlying Type.

有了对 Named 类型与 Underlying Type 的了解,我们就可以对与类型相关的很多行为有更深入的理解了。中将类型概述为 "A type determines a set of values together with operations and methods specific to those values", 简单来说就是值与方法的集合。对于 Named 类型而言,通过类型结构可以发现:值保存在 Underly Type 中,而方法保存在Named 类型之中。所以在形如X.sel的表达式,在不考虑内嵌属性的情况下,如果 sel 是属性,则会从 Underlying Type 中查找,而如果 sel 是方法,则与 Underlying Type 无关。参见如下代码:

上述代码中,类型 A, B, C 的 Underlying Type 都是struct { name string }, 对应, 所以类型 C 引用属性 name 没有问题。而方法getName()定义在类型 A 上,所以通过类型 C 无法引用。对于申明type name decl, name 的 Underlying Type 确定逻辑如下:

接口
Named 类型
类型表达式的类型检查
类型的等价规则
Go Spec
Struct 类型