sanitize.go

Documentation: go/types

     1  // Copyright 2020 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package types
     6  
     7  // sanitizeInfo walks the types contained in info to ensure that all instances
     8  // are expanded.
     9  //
    10  // This includes some objects that may be shared across concurrent
    11  // type-checking passes (such as those in the universe scope), so we are
    12  // careful here not to write types that are already sanitized. This avoids a
    13  // data race as any shared types should already be sanitized.
    14  func sanitizeInfo(info *Info) {
    15  	var s sanitizer = make(map[Type]Type)
    16  
    17  	// Note: Some map entries are not references.
    18  	// If modified, they must be assigned back.
    19  
    20  	for e, tv := range info.Types {
    21  		if typ := s.typ(tv.Type); typ != tv.Type {
    22  			tv.Type = typ
    23  			info.Types[e] = tv
    24  		}
    25  	}
    26  
    27  	inferred := getInferred(info)
    28  	for e, inf := range inferred {
    29  		changed := false
    30  		for i, targ := range inf.Targs {
    31  			if typ := s.typ(targ); typ != targ {
    32  				inf.Targs[i] = typ
    33  				changed = true
    34  			}
    35  		}
    36  		if typ := s.typ(inf.Sig); typ != inf.Sig {
    37  			inf.Sig = typ.(*Signature)
    38  			changed = true
    39  		}
    40  		if changed {
    41  			inferred[e] = inf
    42  		}
    43  	}
    44  
    45  	for _, obj := range info.Defs {
    46  		if obj != nil {
    47  			if typ := s.typ(obj.Type()); typ != obj.Type() {
    48  				obj.setType(typ)
    49  			}
    50  		}
    51  	}
    52  
    53  	for _, obj := range info.Uses {
    54  		if obj != nil {
    55  			if typ := s.typ(obj.Type()); typ != obj.Type() {
    56  				obj.setType(typ)
    57  			}
    58  		}
    59  	}
    60  
    61  	// TODO(gri) sanitize as needed
    62  	// - info.Implicits
    63  	// - info.Selections
    64  	// - info.Scopes
    65  	// - info.InitOrder
    66  }
    67  
    68  type sanitizer map[Type]Type
    69  
    70  func (s sanitizer) typ(typ Type) Type {
    71  	if typ == nil {
    72  		return nil
    73  	}
    74  
    75  	if t, found := s[typ]; found {
    76  		return t
    77  	}
    78  	s[typ] = typ
    79  
    80  	switch t := typ.(type) {
    81  	case *Basic, *bottom, *top:
    82  		// nothing to do
    83  
    84  	case *Array:
    85  		if elem := s.typ(t.elem); elem != t.elem {
    86  			t.elem = elem
    87  		}
    88  
    89  	case *Slice:
    90  		if elem := s.typ(t.elem); elem != t.elem {
    91  			t.elem = elem
    92  		}
    93  
    94  	case *Struct:
    95  		s.varList(t.fields)
    96  
    97  	case *Pointer:
    98  		if base := s.typ(t.base); base != t.base {
    99  			t.base = base
   100  		}
   101  
   102  	case *Tuple:
   103  		s.tuple(t)
   104  
   105  	case *Signature:
   106  		s.var_(t.recv)
   107  		s.tuple(t.params)
   108  		s.tuple(t.results)
   109  
   110  	case *_Sum:
   111  		s.typeList(t.types)
   112  
   113  	case *Interface:
   114  		s.funcList(t.methods)
   115  		if types := s.typ(t.types); types != t.types {
   116  			t.types = types
   117  		}
   118  		s.typeList(t.embeddeds)
   119  		s.funcList(t.allMethods)
   120  		if allTypes := s.typ(t.allTypes); allTypes != t.allTypes {
   121  			t.allTypes = allTypes
   122  		}
   123  
   124  	case *Map:
   125  		if key := s.typ(t.key); key != t.key {
   126  			t.key = key
   127  		}
   128  		if elem := s.typ(t.elem); elem != t.elem {
   129  			t.elem = elem
   130  		}
   131  
   132  	case *Chan:
   133  		if elem := s.typ(t.elem); elem != t.elem {
   134  			t.elem = elem
   135  		}
   136  
   137  	case *Named:
   138  		if debug && t.check != nil {
   139  			panic("internal error: Named.check != nil")
   140  		}
   141  		if orig := s.typ(t.orig); orig != t.orig {
   142  			t.orig = orig
   143  		}
   144  		if under := s.typ(t.underlying); under != t.underlying {
   145  			t.underlying = under
   146  		}
   147  		s.typeList(t.targs)
   148  		s.funcList(t.methods)
   149  
   150  	case *_TypeParam:
   151  		if bound := s.typ(t.bound); bound != t.bound {
   152  			t.bound = bound
   153  		}
   154  
   155  	case *instance:
   156  		typ = t.expand()
   157  		s[t] = typ
   158  
   159  	default:
   160  		panic("unimplemented")
   161  	}
   162  
   163  	return typ
   164  }
   165  
   166  func (s sanitizer) var_(v *Var) {
   167  	if v != nil {
   168  		if typ := s.typ(v.typ); typ != v.typ {
   169  			v.typ = typ
   170  		}
   171  	}
   172  }
   173  
   174  func (s sanitizer) varList(list []*Var) {
   175  	for _, v := range list {
   176  		s.var_(v)
   177  	}
   178  }
   179  
   180  func (s sanitizer) tuple(t *Tuple) {
   181  	if t != nil {
   182  		s.varList(t.vars)
   183  	}
   184  }
   185  
   186  func (s sanitizer) func_(f *Func) {
   187  	if f != nil {
   188  		if typ := s.typ(f.typ); typ != f.typ {
   189  			f.typ = typ
   190  		}
   191  	}
   192  }
   193  
   194  func (s sanitizer) funcList(list []*Func) {
   195  	for _, f := range list {
   196  		s.func_(f)
   197  	}
   198  }
   199  
   200  func (s sanitizer) typeList(list []Type) {
   201  	for i, t := range list {
   202  		if typ := s.typ(t); typ != t {
   203  			list[i] = typ
   204  		}
   205  	}
   206  }
   207
View as plain text