code review 4314054: go/types: New Go type hierarchy implementation for AST.

src/pkg/go/types/const.go

 // Copyright 2011 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.
 
 // This file implements operations on ideal constants.
 
 package types
 
 import (
         "big"
         "go/token"
         "strconv"
 )
 
+
+// TODO(gri) Consider changing the API so Const is an interface
+//           and operations on consts don't have to type switch.
 
 // A Const implements an ideal constant Value.
 // The zero value z for a Const is not a valid constant value.
 type Const struct {
         // representation of constant values:
         // ideal bool     ->  bool
         // ideal int      ->  *big.Int
         // ideal float    ->  *big.Rat
         // ideal complex  ->  cmplx
         // ideal string   ->  string
         val interface{}
 }
 
 
 // Representation of complex values.
 type cmplx struct {
         re, im *big.Rat
 }
 
 
 func assert(cond bool) {
         if !cond {
                 panic("go/types internal error: assertion failed")
         }
 }
 
 
-// NewConst creates a new ideal constant from literal
+// MakeConst makes an ideal constant from a literal
 // token and the corresponding literal string.
-func NewConst(kind token.Token, lit string) Const {
-        switch kind {
+func MakeConst(tok token.Token, lit string) Const {
+        switch tok {
         case token.INT:
                 var x big.Int
                 _, ok := x.SetString(lit, 0)
                 assert(ok)
                 return Const{&x}
         case token.FLOAT:
                 var y big.Rat
                 _, ok := y.SetString(lit)
                 assert(ok)
                 return Const{&y}
@@ skipping 10 matching lines @@
                 return Const{big.NewInt(int64(code))}
         case token.STRING:
                 s, err := strconv.Unquote(lit)
                 assert(err == nil)
                 return Const{s}
         }
         panic("unreachable")
 }
 
 
-// NewZero creates a new zero constant for the given type.
-func NewZero(typ *Type) Const {
+// MakeZero returns the zero constant for the given type.
+func MakeZero(typ *Type) Const {
         // TODO(gri) fix this
         return Const{0}
-}
-
-
-// IsValid returns true if x represents a constant value.
-func (x Const) IsValid() bool {
-        return x.val != nil
 }
 
 
 // Match attempts to match the internal constant representations of x and y.
 // If the attempt is successful, the result is the values of x and y,
 // if necessary converted to have the same internal representation; otherwise
 // the results are invalid.
 func (x Const) Match(y Const) (u, v Const) {
         switch a := x.val.(type) {
         case bool:
                 if _, ok := y.val.(bool); ok {
                         u, v = x, y
                 }
         case *big.Int:
-                switch b := y.val.(type) {
+                switch y.val.(type) {
                 case *big.Int:
                         u, v = x, y
                 case *big.Rat:
                         var z big.Rat
                         z.SetInt(a)
                         u, v = Const{&z}, y
                 case cmplx:
                         var z big.Rat
                         z.SetInt(a)
                         u, v = Const{cmplx{&z, big.NewRat(0, 1)}}, y
                 }
         case *big.Rat:
-                switch b := y.val.(type) {
+                switch y.val.(type) {
                 case *big.Int:
                         v, u = y.Match(x)
                 case *big.Rat:
                         u, v = x, y
                 case cmplx:
                         u, v = Const{cmplx{a, big.NewRat(0, 0)}}, y
                 }
         case cmplx:
-                switch b := y.val.(type) {
+                switch y.val.(type) {
                 case *big.Int, *big.Rat:
                         v, u = y.Match(x)
                 case cmplx:
                         u, v = x, y
                 }
         case string:
                 if _, ok := y.val.(string); ok {
                         u, v = x, y
                 }
         default:
@@ skipping 208 matching lines @@
                 return x < y
         case token.LEQ:
                 return x <= y
         case token.GTR:
                 return x > y
         case token.GEQ:
                 return x >= y
         }
         panic("unreachable")
 }