code review 4035044: Update to current version of Go library.

libgo/go/exp/eval/type.go

 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package eval
 
 import (
         "big"
         "go/ast"
         "go/token"
@@ skipping 36 matching lines @@
         isInteger() bool
         // isFloat returns true if this is a floating type.
         isFloat() bool
         // isIdeal returns true if this is an ideal int or float.
         isIdeal() bool
         // Zero returns a new zero value of this type.
         Zero() Value
         // String returns the string representation of this type.
         String() string
         // The position where this type was defined, if any.
-        Pos() token.Position
+        Pos() token.Pos
 }
 
 type BoundedType interface {
         Type
         // minVal returns the smallest value of this type.
         minVal() *big.Rat
         // maxVal returns the largest value of this type.
         maxVal() *big.Rat
 }
 
-var universePos = token.Position{"<universe>", 0, 0, 0}
+var universePos = token.NoPos
 
 /*
  * Type array maps.  These are used to memoize composite types.
  */
 
 type typeArrayMapEntry struct {
         key  []Type
         v    interface{}
         next *typeArrayMapEntry
 }
@@ skipping 54 matching lines @@
 type commonType struct{}
 
 func (commonType) isBoolean() bool { return false }
 
 func (commonType) isInteger() bool { return false }
 
 func (commonType) isFloat() bool { return false }
 
 func (commonType) isIdeal() bool { return false }
 
-func (commonType) Pos() token.Position { return token.Position{} }
+func (commonType) Pos() token.Pos { return token.NoPos }
 
 /*
  * Bool
  */
 
 type boolType struct {
         commonType
 }
 
 var BoolType = universe.DefineType("bool", universePos, &boolType{})
@@ skipping 211 matching lines @@
 
         // 0 for architecture-dependent type
         Bits uint
 
         name string
 }
 
 var (
         Float32Type = universe.DefineType("float32", universePos, &floatType{commonType{}, 32, "float32"})
         Float64Type = universe.DefineType("float64", universePos, &floatType{commonType{}, 64, "float64"})
-        FloatType   = universe.DefineType("float", universePos, &floatType{commonType{}, 0, "float"})
 )
 
 func (t *floatType) compat(o Type, conv bool) bool {
         t2, ok := o.lit().(*floatType)
         return ok && t == t2
 }
 
 func (t *floatType) lit() Type { return t }
 
 func (t *floatType) isFloat() bool { return true }
 
 func (t *floatType) String() string { return "<" + t.name + ">" }
 
 func (t *floatType) Zero() Value {
         switch t.Bits {
         case 32:
                 res := float32V(0)
                 return &res
         case 64:
                 res := float64V(0)
                 return &res
-        case 0:
-                res := floatV(0)
-                return &res
         }
         panic("unexpected float bit count")
 }
 
 var maxFloat32Val *big.Rat
 var maxFloat64Val *big.Rat
 var minFloat32Val *big.Rat
 var minFloat64Val *big.Rat
 
 func (t *floatType) minVal() *big.Rat {
         bits := t.Bits
-        if bits == 0 {
-                bits = uint(8 * unsafe.Sizeof(float(0)))
-        }
         switch bits {
         case 32:
                 return minFloat32Val
         case 64:
                 return minFloat64Val
         }
         log.Panicf("unexpected floating point bit count: %d", bits)
         panic("unreachable")
 }
 
 func (t *floatType) maxVal() *big.Rat {
         bits := t.Bits
-        if bits == 0 {
-                bits = uint(8 * unsafe.Sizeof(float(0)))
-        }
         switch bits {
         case 32:
                 return maxFloat32Val
         case 64:
                 return maxFloat64Val
         }
         log.Panicf("unexpected floating point bit count: %d", bits)
         panic("unreachable")
 }
 
@@ skipping 654 matching lines @@
 /*
  * Named types
  */
 
 type Method struct {
         decl *FuncDecl
         fn   Func
 }
 
 type NamedType struct {
-        token.Position
-        Name string
+        NamePos token.Pos
+        Name    string
         // Underlying type.  If incomplete is true, this will be nil.
         // If incomplete is false and this is still nil, then this is
         // a placeholder type representing an error.
         Def Type
         // True while this type is being defined.
         incomplete bool
         methods    map[string]Method
 }
 
 // TODO(austin) This is temporarily needed by the debugger's remote
 // type parser.  This should only be possible with block.DefineType.
 func NewNamedType(name string) *NamedType {
-        return &NamedType{token.Position{}, name, nil, true, make(map[string]Method)}
+        return &NamedType{token.NoPos, name, nil, true, make(map[string]Method)}
+}
+
+func (t *NamedType) Pos() token.Pos {
+        return t.NamePos
 }
 
 func (t *NamedType) Complete(def Type) {
         if !t.incomplete {
                 log.Panicf("cannot complete already completed NamedType %+v", *t)
         }
         // We strip the name from def because multiple levels of
         // naming are useless.
         if ndef, ok := def.(*NamedType); ok {
                 def = ndef.Def
@@ skipping 121 matching lines @@
         universe.DefineConst("close", universePos, closeType, nil)
         universe.DefineConst("closed", universePos, closedType, nil)
         universe.DefineConst("copy", universePos, copyType, nil)
         universe.DefineConst("len", universePos, lenType, nil)
         universe.DefineConst("make", universePos, makeType, nil)
         universe.DefineConst("new", universePos, newType, nil)
         universe.DefineConst("panic", universePos, panicType, nil)
         universe.DefineConst("print", universePos, printType, nil)
         universe.DefineConst("println", universePos, printlnType, nil)
 }