Source file src/pkg/go/doc/exports.go
1 // Copyright 2011 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 // This file implements export filtering of an AST. 6 7 package doc 8 9 import "go/ast" 10 11 // filterIdentList removes unexported names from list in place 12 // and returns the resulting list. 13 // 14 func filterIdentList(list []*ast.Ident) []*ast.Ident { 15 j := 0 16 for _, x := range list { 17 if ast.IsExported(x.Name) { 18 list[j] = x 19 j++ 20 } 21 } 22 return list[0:j] 23 } 24 25 // removeErrorField removes anonymous fields named "error" from an interface. 26 // This is called when "error" has been determined to be a local name, 27 // not the predeclared type. 28 // 29 func removeErrorField(ityp *ast.InterfaceType) { 30 list := ityp.Methods.List // we know that ityp.Methods != nil 31 j := 0 32 for _, field := range list { 33 keepField := true 34 if n := len(field.Names); n == 0 { 35 // anonymous field 36 if fname, _ := baseTypeName(field.Type); fname == "error" { 37 keepField = false 38 } 39 } 40 if keepField { 41 list[j] = field 42 j++ 43 } 44 } 45 if j < len(list) { 46 ityp.Incomplete = true 47 } 48 ityp.Methods.List = list[0:j] 49 } 50 51 // filterFieldList removes unexported fields (field names) from the field list 52 // in place and returns true if fields were removed. Anonymous fields are 53 // recorded with the parent type. filterType is called with the types of 54 // all remaining fields. 55 // 56 func (r *reader) filterFieldList(parent *namedType, fields *ast.FieldList, ityp *ast.InterfaceType) (removedFields bool) { 57 if fields == nil { 58 return 59 } 60 list := fields.List 61 j := 0 62 for _, field := range list { 63 keepField := false 64 if n := len(field.Names); n == 0 { 65 // anonymous field 66 fname := r.recordAnonymousField(parent, field.Type) 67 if ast.IsExported(fname) { 68 keepField = true 69 } else if ityp != nil && fname == "error" { 70 // possibly the predeclared error interface; keep 71 // it for now but remember this interface so that 72 // it can be fixed if error is also defined locally 73 keepField = true 74 r.remember(ityp) 75 } 76 } else { 77 field.Names = filterIdentList(field.Names) 78 if len(field.Names) < n { 79 removedFields = true 80 } 81 if len(field.Names) > 0 { 82 keepField = true 83 } 84 } 85 if keepField { 86 r.filterType(nil, field.Type) 87 list[j] = field 88 j++ 89 } 90 } 91 if j < len(list) { 92 removedFields = true 93 } 94 fields.List = list[0:j] 95 return 96 } 97 98 // filterParamList applies filterType to each parameter type in fields. 99 // 100 func (r *reader) filterParamList(fields *ast.FieldList) { 101 if fields != nil { 102 for _, f := range fields.List { 103 r.filterType(nil, f.Type) 104 } 105 } 106 } 107 108 // filterType strips any unexported struct fields or method types from typ 109 // in place. If fields (or methods) have been removed, the corresponding 110 // struct or interface type has the Incomplete field set to true. 111 // 112 func (r *reader) filterType(parent *namedType, typ ast.Expr) { 113 switch t := typ.(type) { 114 case *ast.Ident: 115 // nothing to do 116 case *ast.ParenExpr: 117 r.filterType(nil, t.X) 118 case *ast.ArrayType: 119 r.filterType(nil, t.Elt) 120 case *ast.StructType: 121 if r.filterFieldList(parent, t.Fields, nil) { 122 t.Incomplete = true 123 } 124 case *ast.FuncType: 125 r.filterParamList(t.Params) 126 r.filterParamList(t.Results) 127 case *ast.InterfaceType: 128 if r.filterFieldList(parent, t.Methods, t) { 129 t.Incomplete = true 130 } 131 case *ast.MapType: 132 r.filterType(nil, t.Key) 133 r.filterType(nil, t.Value) 134 case *ast.ChanType: 135 r.filterType(nil, t.Value) 136 } 137 } 138 139 func (r *reader) filterSpec(spec ast.Spec) bool { 140 switch s := spec.(type) { 141 case *ast.ImportSpec: 142 // always keep imports so we can collect them 143 return true 144 case *ast.ValueSpec: 145 s.Names = filterIdentList(s.Names) 146 if len(s.Names) > 0 { 147 r.filterType(nil, s.Type) 148 return true 149 } 150 case *ast.TypeSpec: 151 if name := s.Name.Name; ast.IsExported(name) { 152 r.filterType(r.lookupType(s.Name.Name), s.Type) 153 return true 154 } else if name == "error" { 155 // special case: remember that error is declared locally 156 r.errorDecl = true 157 } 158 } 159 return false 160 } 161 162 func (r *reader) filterSpecList(list []ast.Spec) []ast.Spec { 163 j := 0 164 for _, s := range list { 165 if r.filterSpec(s) { 166 list[j] = s 167 j++ 168 } 169 } 170 return list[0:j] 171 } 172 173 func (r *reader) filterDecl(decl ast.Decl) bool { 174 switch d := decl.(type) { 175 case *ast.GenDecl: 176 d.Specs = r.filterSpecList(d.Specs) 177 return len(d.Specs) > 0 178 case *ast.FuncDecl: 179 // ok to filter these methods early because any 180 // conflicting method will be filtered here, too - 181 // thus, removing these methods early will not lead 182 // to the false removal of possible conflicts 183 return ast.IsExported(d.Name.Name) 184 } 185 return false 186 } 187 188 // fileExports removes unexported declarations from src in place. 189 // 190 func (r *reader) fileExports(src *ast.File) { 191 j := 0 192 for _, d := range src.Decls { 193 if r.filterDecl(d) { 194 src.Decls[j] = d 195 j++ 196 } 197 } 198 src.Decls = src.Decls[0:j] 199 }