golang类型推断与隐式类型转换

// eg.1
a := 1.1
b := 1 + a
// eg.2
a := 1
b := 1.1 + a
// eg.3
a1 := 1
a2 := 1.1
b := a1 + a2
// eg.4
const b = 3 * 0.333
// eg.5
const a int = 1.0
const b = a * 0.333
// eg.6
const a = 1.0/3
b := &a

const k = 5

const k = 5
addr := &k
// invalid operation: cannot take address of k (untyped int constant 5)

const c int = 123
const c int = 123.0
const c int = 123.1 // cannot use 123.1 (untyped float constant) as int value in constant declaration (truncated)

const c float64 = 123.0
const c float64 = 123

const c = 1/2    // 1和2类型相同，无隐式转换发生
const c = 1/2.0  // 整数优先转换为浮点数1.0， c的结果为0.5(float64)
const a int = 1
const c = a * 1.1 // *左边的a是已定义类型的常量，因此1.1将被转换为int，但浮点数1.1与整形不兼容，无法进行转换，因此编译器会报错
//  (untyped float constant) truncated to int 

// go/src/cmd/compile/internal/typecheck/const.go
func defaultlit2(l ir.Node, r ir.Node, force bool) (ir.Node, ir.Node) {
	if l.Type() == nil || r.Type() == nil {
            return l, r
	}

	if !l.Type().IsInterface() && !r.Type().IsInterface() {
            // Can't mix bool with non-bool, string with non-string.
            if l.Type().IsBoolean() != r.Type().IsBoolean() {
                return l, r
            }
            if l.Type().IsString() != r.Type().IsString() {
                return l, r
            }
	}
	if !l.Type().IsUntyped() {
            r = convlit(r, l.Type())
            return l, r
	}
	if !r.Type().IsUntyped() {
            l = convlit(l, r.Type())
            return l, r
	}
	if !force {
            return l, r
	}
	// Can't mix nil with anything untyped.
	if ir.IsNil(l) || ir.IsNil(r) {
            return l, r
	}
	t := defaultType(mixUntyped(l.Type(), r.Type()))
	l = convlit(l, t)
	r = convlit(r, t)
	return l, r
}

c := true + 12 // 错误

c := "123" + 12 // 错误

c := nil + 12 // 错误

const a int = 1
const b int = 1.0
const c = a + 1.0 // 1.0转换为a的类型int
const c = a + b // b的类型已经在前面转换为int

const a int = 1
const c = 1.0 + a // 1.0转换为a的类型int

const a int = 1
const b int = 1.0
const c = a + 1.0
const c = a + b 
const c = 1.0 + b

a := 123 
var a = 123
var a int = 123.0

// go/src/cmd/compile/internal/syntax/scanner.go
func (s *scanner) next() {
  ...
  switch s.ch {
	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
          s.number(false)

	case '"':
          s.stdString()

	case '`':
          s.rawString()

	case '\'':
          s.rune()
    ...
  }
}

// go/src/cmd/compile/internal/syntax/scanner.go
func (s *scanner) number(seenPoint bool) {
  ...
  base := 10        // number base
  ...
  // integer part
  if !seenPoint {
      if s.ch == '0' {
          s.nextch()
          switch lower(s.ch) {
          case 'x':
              s.nextch()
              base, prefix = 16, 'x'
          case 'o':
              s.nextch()
              base, prefix = 8, 'o'
          case 'b':
              s.nextch()
              base, prefix = 2, 'b'
          default:
              base, prefix = 8, '0'
              digsep = 1 // leading 0
          }
      digsep |= s.digits(base, &invalid)
      ...
      }
	...
  }
  // fractional part
  if seenPoint {
          kind = FloatLit
          digsep |= s.digits(base, &invalid)
  }
 ...
}

// go/src/cmd/compile/internal/syntax/nodes.go
type (
  ...
  AssignStmt struct {
      Op       Operator // 0 means no operation
      Lhs, Rhs Expr     // Rhs == nil means Lhs++ (Op == Add) or Lhs-- (Op == Sub)
      simpleStmt
  }
  ...
)

// go/src/cmd/compile/internal/ir/node.go
// An AssignStmt is a simple assignment statement: X = Y.
// If Def is true, the assignment is a :=.
type AssignStmt struct {
  miniStmt
  X   Node
  Def bool
  Y   Node
}
// A Node is the abstract interface to an IR node.
type Node interface {
  ...
  // Source position.
  Pos() src.XPos
  SetPos(x src.XPos)
  ...
  // Fields specific to certain Ops only.
  Type() *types.Type
  SetType(t *types.Type)
  Val() constant.Value
  SetVal(v constant.Value)
  ...
  // Typecheck values:
  //  0 means the node is not typechecked
  //  1 means the node is completely typechecked
  //  2 means typechecking of the node is in progress
  //  3 means the node has its type from types2, but may need transformation
  Typecheck() uint8
  SetTypecheck(x uint8)
}

// go/src/cmd/compile/internal/typecheck/stmt.go
// type check assignment.
// if this assignment is the definition of a var on the left side,
// fill in the var's type.
func tcAssign(n *ir.AssignStmt) {
  ...
  lhs, rhs := []ir.Node{n.X}, []ir.Node{n.Y}
  assign(n, lhs, rhs)
  ...
}
func assign(stmt ir.Node, lhs, rhs []ir.Node) {
  ...
  assignType := func(i int, typ *types.Type) {
    checkLHS(i, typ)
    if typ != nil {
      checkassignto(typ, lhs[i])
    }
  }
  ...
  assignType(0, r.Type())
  ...
}

// go/src/cmd/compile/internal/typecheck/typecheck.go
func checkassignto(src *types.Type, dst ir.Node) {
  ...
  if op, why := Assignop(src, dst.Type()); op == ir.OXXX {
      base.Errorf("cannot assign %v to %L in multiple assignment%s", src, dst, why)
      return
  }
 }

a := 123 
var a = 123
var a int = 123.0