├── .gitignore ├── LICENSE ├── Makefile ├── README.md ├── cache ├── ArchiveTar.v2.json ├── ArchiveZip.v2.json ├── Bufio.v2.json ├── Bytes.v2.json ├── CompressBzip2.v2.json ├── CompressFlate.v2.json ├── CompressGzip.v2.json ├── CompressLzw.v2.json ├── CompressZlib.v2.json ├── ContainerHeap.v2.json ├── ContainerList.v2.json ├── ContainerRing.v2.json ├── Context.v2.json ├── Crypto.v2.json ├── CryptoCipher.v2.json ├── CryptoEcdsa.v2.json ├── CryptoEd25519.v2.json ├── CryptoRsa.v2.json ├── CryptoTls.v2.json ├── CryptoX509.v2.json ├── DatabaseSql.v2.json ├── DatabaseSqlDriver.v2.json ├── Encoding.v2.json ├── EncodingAscii85.v2.json ├── EncodingAsn1.v2.json ├── EncodingBase32.v2.json ├── EncodingBase64.v2.json ├── EncodingBinary.v2.json ├── EncodingCsv.v2.json ├── EncodingGob.v2.json ├── EncodingHex.v2.json ├── EncodingJson.v2.json ├── EncodingPem.v2.json ├── EncodingXml.v2.json ├── Errors.v2.json ├── Expvar.v2.json ├── Fmt.v2.json ├── HashMaphash.v2.json ├── Html.v2.json ├── HtmlTemplate.v2.json ├── Io.v2.json ├── IoIoutil.v2.json ├── Log.v2.json ├── LogSyslog.v2.json ├── Mime.v2.json ├── MimeMultipart.v2.json ├── MimeQuotedprintable.v2.json ├── Net.v2.json ├── NetHttp.v2.json ├── NetHttpCgi.v2.json ├── NetHttpCookiejar.v2.json ├── NetHttpFcgi.v2.json ├── NetHttpHttputil.v2.json ├── NetMail.v2.json ├── NetRpc.v2.json ├── NetRpcJsonrpc.v2.json ├── NetTextproto.v2.json ├── NetUrl.v2.json ├── Os.v2.json ├── OsUser.v2.json ├── Path.v2.json ├── PathFilepath.v2.json ├── Reflect.v2.json ├── Regexp.v2.json ├── Sort.v2.json ├── Strconv.v2.json ├── Strings.v2.json ├── Sync.v2.json ├── SyncAtomic.v2.json ├── Syscall.v2.json ├── TextScanner.v2.json ├── TextTabwriter.v2.json ├── TextTemplate.v2.json ├── Unicode.v2.json ├── UnicodeUtf16.v2.json └── UnicodeUtf8.v2.json ├── count-imports.sh ├── deprecated ├── demo-jennifer │ └── main.go └── demo-package │ ├── generated │ └── main.go │ └── pkg.go ├── go.mod ├── go.sum ├── gogentools └── tools.go ├── index.html ├── main.go ├── queries ├── NegativeTestTaintFlow.ql └── PositiveTestTaintFlow.ql ├── scanner ├── LICENSE.txt ├── context.go ├── context_test.go ├── package.go ├── package_test.go ├── scanner.go └── scanner_test.go ├── standard-library.md ├── static ├── bootstrap.min.css ├── bootstrap.min.js ├── jquery-3.4.1.slim.min.js ├── popper.min.js ├── vue-dev.js └── vue.js ├── templates ├── taint-tracking_function.txt ├── taint-tracking_interface-method.txt ├── taint-tracking_type-method.txt └── v2-compressed-taint-tracking.txt └── top-stdlib-go.txt /.gitignore: -------------------------------------------------------------------------------- 1 | /src/* 2 | /generated/* 3 | /volumes/* -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 gagliardetto github.com/gagliardetto 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | .DEFAULT_GOAL := install 2 | install: 3 | go build -o $$GOPATH/bin/codebox 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | **Summary**: Codebox is a **graphical tool** that helps to **create taint-tracking models** for **Go** functions/methods/interfaces. 2 | 3 | You specify the **taint logic** in a graphical (**web**) interface, and it **generates CodeQL taint-tracking models** along with Go scenario **test cases** for those models. 4 | 5 | ![codebox_screenshot](https://user-images.githubusercontent.com/15271561/86345187-e2bc5900-bc63-11ea-95e5-5f5e63e7040f.png) 6 | 7 | # Example 8 | 9 | The `codebox` tool was created to expand the **taint-tracking models** of [codeql-go](https://github.com/github/codeql-go) (the official CodeQL extractor and libraries for Go.) 10 | 11 | You can find below all the models and tests that were generated by `codebox` and then merged into the [codeql-go](https://github.com/github/codeql-go) repo: 12 | - Taint-tracking models: https://github.com/github/codeql-go/tree/main/ql/src/semmle/go/frameworks/stdlib 13 | - Tests: https://github.com/github/codeql-go/tree/main/ql/test/library-tests/semmle/go/frameworks/StdlibTaintFlow 14 | - Imports: https://github.com/github/codeql-go/blob/main/ql/src/semmle/go/frameworks/Stdlib.qll#L6-L65 15 | - More about the goal: https://github.com/github/securitylab/issues/187 16 | 17 | NOTE: The `codebox` tool and its author have no affiliation with GitHub/Semmle. 18 | 19 | # How it works 20 | 21 | ```bash 22 | # - go get 23 | go get github.com/gagliardetto/codebox 24 | 25 | # - Enter the codebox folder: 26 | cd $GOPATH/src/github.com/gagliardetto/codebox 27 | 28 | # - Compile and install the binary: 29 | make 30 | 31 | # - Spin up the graphical tool http server for e.g. the "io" package. 32 | # NOTE: You still need to be inside $GOPATH/src/github.com/gagliardetto/codebox (to be able to access static assets) 33 | # NOTE: You need to have Go installed to be able to analyze standard library packages. 34 | # NOTE: The --pkg flag can either be (defaults to latest version), or @; 35 | # e.g. github.com/gin-gonic/gin@latest 36 | # e.g. github.com/gin-gonic/gin@v1.6.2 37 | # NOTE: There might be some issues with some packages or modules. 38 | # NOTE: The --out-dir flag is the folder where all the generated files will go. 39 | codebox --out-dir=./generated/compressed --pkg=net/http --stub --http 40 | 41 | # - Open the UI in the browser: 42 | chrome http://127.0.0.1:8080/ 43 | 44 | # - Now that you see the UI in the browser, complete the taint-tracking logic 45 | # and when you're done, close the server program you started in the terminal 46 | # with a CTRL-C. 47 | # You will find the generated codeql and golang files inside ./generated/compressed 48 | 49 | # NOTE: if you only want to regenerate the code without starting the server, 50 | # then you need to remove the --http flag: 51 | codebox --out-dir=./generated/compressed --pkg=net/http --stub 52 | ``` 53 | 54 | # Helpful commands for batch processing 55 | 56 | ```bash 57 | # Move all files from child directories to parent directory: 58 | # find . -mindepth 2 -type f -name "*.go" -print -exec mv {} . \; 59 | # find . -mindepth 2 -type f -name "*.qll" -print -exec mv {} . \; 60 | find . -mindepth 2 -type f -print -exec mv {} . \; 61 | 62 | #for f in *.qll; do printf '%s\n' "${f%.qll}TaintTracking.qll"; done 63 | 64 | rename 's/\.qll$/TaintTracking.qll/' *.qll 65 | 66 | # format a codeql file: 67 | codeql query format -qq -i file.qll 68 | 69 | # format all codeql files: 70 | 71 | echo ~/.config/Code/User/globalStorage/github.vscode-codeql/distribution*/codeql/codeql 72 | find . -type f -name "*.ql" -or -name "*.qll" -exec ~/.config/Code/User/globalStorage/github.vscode-codeql/distribution12/codeql/codeql query format -qq -i {} ';' -print 73 | 74 | find . -type f -name "*.ql" -or -name "*.qll" | while read cqlFile; do echo $cqlFile && codeql query format -qq -i $cqlFile; done 75 | 76 | 77 | ``` 78 | -------------------------------------------------------------------------------- /cache/ArchiveTar.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Header).FileInfo() os.FileInfo": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | true 12 | ] 13 | } 14 | ], 15 | "IsEnabled": true 16 | }, 17 | "func (*Reader).Next() (*Header, error)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | true, 22 | false, 23 | false 24 | ], 25 | "Outp": [ 26 | false, 27 | true, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": true 33 | }, 34 | "func (*Reader).Read(b []byte) (int, error)": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | true, 39 | false, 40 | false, 41 | false 42 | ], 43 | "Outp": [ 44 | false, 45 | true, 46 | false, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": true 52 | }, 53 | "func (*Writer).Close() error": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | false 59 | ], 60 | "Outp": [ 61 | false, 62 | false 63 | ] 64 | } 65 | ], 66 | "IsEnabled": false 67 | }, 68 | "func (*Writer).Flush() error": { 69 | "Blocks": [ 70 | { 71 | "Inp": [ 72 | false, 73 | false 74 | ], 75 | "Outp": [ 76 | false, 77 | false 78 | ] 79 | } 80 | ], 81 | "IsEnabled": false 82 | }, 83 | "func (*Writer).Write(b []byte) (int, error)": { 84 | "Blocks": [ 85 | { 86 | "Inp": [ 87 | false, 88 | true, 89 | false, 90 | false 91 | ], 92 | "Outp": [ 93 | true, 94 | false, 95 | false, 96 | false 97 | ] 98 | } 99 | ], 100 | "IsEnabled": true 101 | }, 102 | "func (*Writer).WriteHeader(hdr *Header) error": { 103 | "Blocks": [ 104 | { 105 | "Inp": [ 106 | false, 107 | true, 108 | false 109 | ], 110 | "Outp": [ 111 | true, 112 | false, 113 | false 114 | ] 115 | } 116 | ], 117 | "IsEnabled": true 118 | }, 119 | "func (Format).String() string": { 120 | "Blocks": [ 121 | { 122 | "Inp": [ 123 | false, 124 | false 125 | ], 126 | "Outp": [ 127 | false, 128 | false 129 | ] 130 | } 131 | ], 132 | "IsEnabled": false 133 | }, 134 | "func FileInfoHeader(fi os.FileInfo, link string) (*Header, error)": { 135 | "Blocks": [ 136 | { 137 | "Inp": [ 138 | true, 139 | false, 140 | false, 141 | false 142 | ], 143 | "Outp": [ 144 | false, 145 | false, 146 | true, 147 | false 148 | ] 149 | } 150 | ], 151 | "IsEnabled": true 152 | }, 153 | "func NewReader(r io.Reader) *Reader": { 154 | "Blocks": [ 155 | { 156 | "Inp": [ 157 | true, 158 | false 159 | ], 160 | "Outp": [ 161 | false, 162 | true 163 | ] 164 | } 165 | ], 166 | "IsEnabled": true 167 | }, 168 | "func NewWriter(w io.Writer) *Writer": { 169 | "Blocks": [ 170 | { 171 | "Inp": [ 172 | false, 173 | true 174 | ], 175 | "Outp": [ 176 | true, 177 | false 178 | ] 179 | } 180 | ], 181 | "IsEnabled": true 182 | } 183 | } 184 | -------------------------------------------------------------------------------- /cache/ArchiveZip.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*File).DataOffset() (offset int64, err error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (*File).Open() (io.ReadCloser, error)": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | true, 24 | false, 25 | false 26 | ], 27 | "Outp": [ 28 | false, 29 | true, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": true 35 | }, 36 | "func (*FileHeader).FileInfo() os.FileInfo": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | true, 41 | false 42 | ], 43 | "Outp": [ 44 | false, 45 | true 46 | ] 47 | } 48 | ], 49 | "IsEnabled": false 50 | }, 51 | "func (*FileHeader).ModTime() time.Time": { 52 | "Blocks": [ 53 | { 54 | "Inp": [ 55 | false, 56 | false 57 | ], 58 | "Outp": [ 59 | false, 60 | false 61 | ] 62 | } 63 | ], 64 | "IsEnabled": false 65 | }, 66 | "func (*FileHeader).Mode() (mode os.FileMode)": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | true, 71 | false 72 | ], 73 | "Outp": [ 74 | false, 75 | true 76 | ] 77 | } 78 | ], 79 | "IsEnabled": false 80 | }, 81 | "func (*FileHeader).SetModTime(t time.Time)": { 82 | "Blocks": [ 83 | { 84 | "Inp": [ 85 | false, 86 | false 87 | ], 88 | "Outp": [ 89 | false, 90 | false 91 | ] 92 | } 93 | ], 94 | "IsEnabled": false 95 | }, 96 | "func (*FileHeader).SetMode(mode os.FileMode)": { 97 | "Blocks": [ 98 | { 99 | "Inp": [ 100 | false, 101 | true 102 | ], 103 | "Outp": [ 104 | true, 105 | false 106 | ] 107 | } 108 | ], 109 | "IsEnabled": false 110 | }, 111 | "func (*ReadCloser).Close() error": { 112 | "Blocks": [ 113 | { 114 | "Inp": [ 115 | false, 116 | false 117 | ], 118 | "Outp": [ 119 | false, 120 | false 121 | ] 122 | } 123 | ], 124 | "IsEnabled": false 125 | }, 126 | "func (*Reader).RegisterDecompressor(method uint16, dcomp Decompressor)": { 127 | "Blocks": [ 128 | { 129 | "Inp": [ 130 | false, 131 | false, 132 | true 133 | ], 134 | "Outp": [ 135 | true, 136 | false, 137 | false 138 | ] 139 | } 140 | ], 141 | "IsEnabled": false 142 | }, 143 | "func (*Writer).Close() error": { 144 | "Blocks": [ 145 | { 146 | "Inp": [ 147 | false, 148 | false 149 | ], 150 | "Outp": [ 151 | false, 152 | false 153 | ] 154 | } 155 | ], 156 | "IsEnabled": false 157 | }, 158 | "func (*Writer).Create(name string) (io.Writer, error)": { 159 | "Blocks": [ 160 | { 161 | "Inp": [ 162 | false, 163 | false, 164 | true, 165 | false 166 | ], 167 | "Outp": [ 168 | true, 169 | false, 170 | false, 171 | false 172 | ] 173 | } 174 | ], 175 | "IsEnabled": true 176 | }, 177 | "func (*Writer).CreateHeader(fh *FileHeader) (io.Writer, error)": { 178 | "Blocks": [ 179 | { 180 | "Inp": [ 181 | false, 182 | false, 183 | true, 184 | false 185 | ], 186 | "Outp": [ 187 | true, 188 | false, 189 | false, 190 | false 191 | ] 192 | } 193 | ], 194 | "IsEnabled": true 195 | }, 196 | "func (*Writer).Flush() error": { 197 | "Blocks": [ 198 | { 199 | "Inp": [ 200 | false, 201 | false 202 | ], 203 | "Outp": [ 204 | false, 205 | false 206 | ] 207 | } 208 | ], 209 | "IsEnabled": false 210 | }, 211 | "func (*Writer).RegisterCompressor(method uint16, comp Compressor)": { 212 | "Blocks": [ 213 | { 214 | "Inp": [ 215 | false, 216 | false, 217 | true 218 | ], 219 | "Outp": [ 220 | true, 221 | false, 222 | false 223 | ] 224 | } 225 | ], 226 | "IsEnabled": false 227 | }, 228 | "func (*Writer).SetComment(comment string) error": { 229 | "Blocks": [ 230 | { 231 | "Inp": [ 232 | false, 233 | true, 234 | false 235 | ], 236 | "Outp": [ 237 | true, 238 | false, 239 | false 240 | ] 241 | } 242 | ], 243 | "IsEnabled": false 244 | }, 245 | "func (*Writer).SetOffset(n int64)": { 246 | "Blocks": [ 247 | { 248 | "Inp": [ 249 | false, 250 | false 251 | ], 252 | "Outp": [ 253 | false, 254 | false 255 | ] 256 | } 257 | ], 258 | "IsEnabled": false 259 | }, 260 | "func FileInfoHeader(fi os.FileInfo) (*FileHeader, error)": { 261 | "Blocks": [ 262 | { 263 | "Inp": [ 264 | true, 265 | false, 266 | false 267 | ], 268 | "Outp": [ 269 | false, 270 | true, 271 | false 272 | ] 273 | } 274 | ], 275 | "IsEnabled": true 276 | }, 277 | "func NewReader(r io.ReaderAt, size int64) (*Reader, error)": { 278 | "Blocks": [ 279 | { 280 | "Inp": [ 281 | true, 282 | false, 283 | false, 284 | false 285 | ], 286 | "Outp": [ 287 | false, 288 | false, 289 | true, 290 | false 291 | ] 292 | } 293 | ], 294 | "IsEnabled": true 295 | }, 296 | "func NewWriter(w io.Writer) *Writer": { 297 | "Blocks": [ 298 | { 299 | "Inp": [ 300 | false, 301 | true 302 | ], 303 | "Outp": [ 304 | true, 305 | false 306 | ] 307 | } 308 | ], 309 | "IsEnabled": true 310 | }, 311 | "func OpenReader(name string) (*ReadCloser, error)": { 312 | "Blocks": [ 313 | { 314 | "Inp": [ 315 | true, 316 | false, 317 | false 318 | ], 319 | "Outp": [ 320 | false, 321 | true, 322 | false 323 | ] 324 | } 325 | ], 326 | "IsEnabled": true 327 | }, 328 | "func RegisterCompressor(method uint16, comp Compressor)": { 329 | "Blocks": [ 330 | { 331 | "Inp": [ 332 | false, 333 | false 334 | ], 335 | "Outp": [ 336 | false, 337 | false 338 | ] 339 | } 340 | ], 341 | "IsEnabled": false 342 | }, 343 | "func RegisterDecompressor(method uint16, dcomp Decompressor)": { 344 | "Blocks": [ 345 | { 346 | "Inp": [ 347 | false, 348 | false 349 | ], 350 | "Outp": [ 351 | false, 352 | false 353 | ] 354 | } 355 | ], 356 | "IsEnabled": false 357 | } 358 | } 359 | -------------------------------------------------------------------------------- /cache/CompressBzip2.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (StructuralError).Error() string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func NewReader(r io.Reader) io.Reader": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | true, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | true 27 | ] 28 | } 29 | ], 30 | "IsEnabled": true 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /cache/CompressFlate.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*ReadError).Error() string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*WriteError).Error() string": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | false 27 | ] 28 | } 29 | ], 30 | "IsEnabled": false 31 | }, 32 | "func (*Writer).Close() error": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | false, 37 | false 38 | ], 39 | "Outp": [ 40 | false, 41 | false 42 | ] 43 | } 44 | ], 45 | "IsEnabled": false 46 | }, 47 | "func (*Writer).Flush() error": { 48 | "Blocks": [ 49 | { 50 | "Inp": [ 51 | false, 52 | false 53 | ], 54 | "Outp": [ 55 | false, 56 | false 57 | ] 58 | } 59 | ], 60 | "IsEnabled": false 61 | }, 62 | "func (*Writer).Reset(dst io.Writer)": { 63 | "Blocks": [ 64 | { 65 | "Inp": [ 66 | true, 67 | false 68 | ], 69 | "Outp": [ 70 | false, 71 | true 72 | ] 73 | } 74 | ], 75 | "IsEnabled": true 76 | }, 77 | "func (*Writer).Write(data []byte) (n int, err error)": { 78 | "Blocks": [ 79 | { 80 | "Inp": [ 81 | false, 82 | true, 83 | false, 84 | false 85 | ], 86 | "Outp": [ 87 | true, 88 | false, 89 | false, 90 | false 91 | ] 92 | } 93 | ], 94 | "IsEnabled": true 95 | }, 96 | "func (CorruptInputError).Error() string": { 97 | "Blocks": [ 98 | { 99 | "Inp": [ 100 | false, 101 | false 102 | ], 103 | "Outp": [ 104 | false, 105 | false 106 | ] 107 | } 108 | ], 109 | "IsEnabled": false 110 | }, 111 | "func (InternalError).Error() string": { 112 | "Blocks": [ 113 | { 114 | "Inp": [ 115 | false, 116 | false 117 | ], 118 | "Outp": [ 119 | false, 120 | false 121 | ] 122 | } 123 | ], 124 | "IsEnabled": false 125 | }, 126 | "func (Resetter).Reset(r io.Reader, dict []byte) error": { 127 | "Blocks": [ 128 | { 129 | "Inp": [ 130 | false, 131 | true, 132 | false, 133 | false 134 | ], 135 | "Outp": [ 136 | true, 137 | false, 138 | false, 139 | false 140 | ] 141 | } 142 | ], 143 | "IsEnabled": true 144 | }, 145 | "func NewReader(r io.Reader) io.ReadCloser": { 146 | "Blocks": [ 147 | { 148 | "Inp": [ 149 | true, 150 | false 151 | ], 152 | "Outp": [ 153 | false, 154 | true 155 | ] 156 | } 157 | ], 158 | "IsEnabled": true 159 | }, 160 | "func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser": { 161 | "Blocks": [ 162 | { 163 | "Inp": [ 164 | true, 165 | false, 166 | false 167 | ], 168 | "Outp": [ 169 | false, 170 | false, 171 | true 172 | ] 173 | } 174 | ], 175 | "IsEnabled": true 176 | }, 177 | "func NewWriter(w io.Writer, level int) (*Writer, error)": { 178 | "Blocks": [ 179 | { 180 | "Inp": [ 181 | false, 182 | false, 183 | true, 184 | false 185 | ], 186 | "Outp": [ 187 | true, 188 | false, 189 | false, 190 | false 191 | ] 192 | } 193 | ], 194 | "IsEnabled": true 195 | }, 196 | "func NewWriterDict(w io.Writer, level int, dict []byte) (*Writer, error)": { 197 | "Blocks": [ 198 | { 199 | "Inp": [ 200 | false, 201 | false, 202 | false, 203 | true, 204 | false 205 | ], 206 | "Outp": [ 207 | true, 208 | false, 209 | false, 210 | false, 211 | false 212 | ] 213 | } 214 | ], 215 | "IsEnabled": true 216 | } 217 | } 218 | -------------------------------------------------------------------------------- /cache/CompressGzip.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Reader).Close() error": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*Reader).Multistream(ok bool)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | false 27 | ] 28 | } 29 | ], 30 | "IsEnabled": false 31 | }, 32 | "func (*Reader).Read(p []byte) (n int, err error)": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | true, 37 | false, 38 | false, 39 | false 40 | ], 41 | "Outp": [ 42 | false, 43 | true, 44 | false, 45 | false 46 | ] 47 | } 48 | ], 49 | "IsEnabled": true 50 | }, 51 | "func (*Reader).Reset(r io.Reader) error": { 52 | "Blocks": [ 53 | { 54 | "Inp": [ 55 | false, 56 | true, 57 | false 58 | ], 59 | "Outp": [ 60 | true, 61 | false, 62 | false 63 | ] 64 | } 65 | ], 66 | "IsEnabled": true 67 | }, 68 | "func (*Writer).Close() error": { 69 | "Blocks": [ 70 | { 71 | "Inp": [ 72 | false, 73 | false 74 | ], 75 | "Outp": [ 76 | false, 77 | false 78 | ] 79 | } 80 | ], 81 | "IsEnabled": false 82 | }, 83 | "func (*Writer).Flush() error": { 84 | "Blocks": [ 85 | { 86 | "Inp": [ 87 | false, 88 | false 89 | ], 90 | "Outp": [ 91 | false, 92 | false 93 | ] 94 | } 95 | ], 96 | "IsEnabled": false 97 | }, 98 | "func (*Writer).Reset(w io.Writer)": { 99 | "Blocks": [ 100 | { 101 | "Inp": [ 102 | true, 103 | false 104 | ], 105 | "Outp": [ 106 | false, 107 | true 108 | ] 109 | } 110 | ], 111 | "IsEnabled": true 112 | }, 113 | "func (*Writer).Write(p []byte) (int, error)": { 114 | "Blocks": [ 115 | { 116 | "Inp": [ 117 | false, 118 | true, 119 | false, 120 | false 121 | ], 122 | "Outp": [ 123 | true, 124 | false, 125 | false, 126 | false 127 | ] 128 | } 129 | ], 130 | "IsEnabled": true 131 | }, 132 | "func NewReader(r io.Reader) (*Reader, error)": { 133 | "Blocks": [ 134 | { 135 | "Inp": [ 136 | true, 137 | false, 138 | false 139 | ], 140 | "Outp": [ 141 | false, 142 | true, 143 | false 144 | ] 145 | } 146 | ], 147 | "IsEnabled": true 148 | }, 149 | "func NewWriter(w io.Writer) *Writer": { 150 | "Blocks": [ 151 | { 152 | "Inp": [ 153 | false, 154 | true 155 | ], 156 | "Outp": [ 157 | true, 158 | false 159 | ] 160 | } 161 | ], 162 | "IsEnabled": true 163 | }, 164 | "func NewWriterLevel(w io.Writer, level int) (*Writer, error)": { 165 | "Blocks": [ 166 | { 167 | "Inp": [ 168 | false, 169 | false, 170 | true, 171 | false 172 | ], 173 | "Outp": [ 174 | true, 175 | false, 176 | false, 177 | false 178 | ] 179 | } 180 | ], 181 | "IsEnabled": true 182 | } 183 | } 184 | -------------------------------------------------------------------------------- /cache/CompressLzw.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func NewReader(r io.Reader, order Order, litWidth int) io.ReadCloser": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false, 9 | false 10 | ], 11 | "Outp": [ 12 | false, 13 | false, 14 | false, 15 | true 16 | ] 17 | } 18 | ], 19 | "IsEnabled": true 20 | }, 21 | "func NewWriter(w io.Writer, order Order, litWidth int) io.WriteCloser": { 22 | "Blocks": [ 23 | { 24 | "Inp": [ 25 | false, 26 | false, 27 | false, 28 | true 29 | ], 30 | "Outp": [ 31 | true, 32 | false, 33 | false, 34 | false 35 | ] 36 | } 37 | ], 38 | "IsEnabled": true 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /cache/CompressZlib.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Writer).Close() error": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*Writer).Flush() error": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | false 27 | ] 28 | } 29 | ], 30 | "IsEnabled": false 31 | }, 32 | "func (*Writer).Reset(w io.Writer)": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | true, 37 | false 38 | ], 39 | "Outp": [ 40 | false, 41 | true 42 | ] 43 | } 44 | ], 45 | "IsEnabled": true 46 | }, 47 | "func (*Writer).Write(p []byte) (n int, err error)": { 48 | "Blocks": [ 49 | { 50 | "Inp": [ 51 | false, 52 | true, 53 | false, 54 | false 55 | ], 56 | "Outp": [ 57 | true, 58 | false, 59 | false, 60 | false 61 | ] 62 | } 63 | ], 64 | "IsEnabled": true 65 | }, 66 | "func (Resetter).Reset(r io.Reader, dict []byte) error": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | false, 71 | true, 72 | false, 73 | false 74 | ], 75 | "Outp": [ 76 | true, 77 | false, 78 | false, 79 | false 80 | ] 81 | } 82 | ], 83 | "IsEnabled": true 84 | }, 85 | "func NewReader(r io.Reader) (io.ReadCloser, error)": { 86 | "Blocks": [ 87 | { 88 | "Inp": [ 89 | true, 90 | false, 91 | false 92 | ], 93 | "Outp": [ 94 | false, 95 | true, 96 | false 97 | ] 98 | } 99 | ], 100 | "IsEnabled": true 101 | }, 102 | "func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error)": { 103 | "Blocks": [ 104 | { 105 | "Inp": [ 106 | true, 107 | false, 108 | false, 109 | false 110 | ], 111 | "Outp": [ 112 | false, 113 | false, 114 | true, 115 | false 116 | ] 117 | } 118 | ], 119 | "IsEnabled": true 120 | }, 121 | "func NewWriter(w io.Writer) *Writer": { 122 | "Blocks": [ 123 | { 124 | "Inp": [ 125 | false, 126 | true 127 | ], 128 | "Outp": [ 129 | true, 130 | false 131 | ] 132 | } 133 | ], 134 | "IsEnabled": true 135 | }, 136 | "func NewWriterLevel(w io.Writer, level int) (*Writer, error)": { 137 | "Blocks": [ 138 | { 139 | "Inp": [ 140 | false, 141 | false, 142 | true, 143 | false 144 | ], 145 | "Outp": [ 146 | true, 147 | false, 148 | false, 149 | false 150 | ] 151 | } 152 | ], 153 | "IsEnabled": true 154 | }, 155 | "func NewWriterLevelDict(w io.Writer, level int, dict []byte) (*Writer, error)": { 156 | "Blocks": [ 157 | { 158 | "Inp": [ 159 | false, 160 | false, 161 | false, 162 | true, 163 | false 164 | ], 165 | "Outp": [ 166 | true, 167 | false, 168 | false, 169 | false, 170 | false 171 | ] 172 | } 173 | ], 174 | "IsEnabled": true 175 | } 176 | } 177 | -------------------------------------------------------------------------------- /cache/ContainerHeap.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (Interface).Pop() interface{}": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | true 12 | ] 13 | } 14 | ], 15 | "IsEnabled": true 16 | }, 17 | "func (Interface).Push(x interface{})": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | true 23 | ], 24 | "Outp": [ 25 | true, 26 | false 27 | ] 28 | } 29 | ], 30 | "IsEnabled": true 31 | }, 32 | "func Fix(h Interface, i int)": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | false, 37 | false 38 | ], 39 | "Outp": [ 40 | false, 41 | false 42 | ] 43 | } 44 | ], 45 | "IsEnabled": false 46 | }, 47 | "func Init(h Interface)": { 48 | "Blocks": [ 49 | { 50 | "Inp": [ 51 | false 52 | ], 53 | "Outp": [ 54 | false 55 | ] 56 | } 57 | ], 58 | "IsEnabled": false 59 | }, 60 | "func Pop(h Interface) interface{}": { 61 | "Blocks": [ 62 | { 63 | "Inp": [ 64 | true, 65 | false 66 | ], 67 | "Outp": [ 68 | false, 69 | true 70 | ] 71 | } 72 | ], 73 | "IsEnabled": true 74 | }, 75 | "func Push(h Interface, x interface{})": { 76 | "Blocks": [ 77 | { 78 | "Inp": [ 79 | false, 80 | true 81 | ], 82 | "Outp": [ 83 | true, 84 | false 85 | ] 86 | } 87 | ], 88 | "IsEnabled": true 89 | }, 90 | "func Remove(h Interface, i int) interface{}": { 91 | "Blocks": [ 92 | { 93 | "Inp": [ 94 | true, 95 | false, 96 | false 97 | ], 98 | "Outp": [ 99 | false, 100 | false, 101 | true 102 | ] 103 | } 104 | ], 105 | "IsEnabled": true 106 | } 107 | } 108 | -------------------------------------------------------------------------------- /cache/ContainerList.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Element).Next() *Element": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | true 12 | ] 13 | } 14 | ], 15 | "IsEnabled": true 16 | }, 17 | "func (*Element).Prev() *Element": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | true, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | true 27 | ] 28 | } 29 | ], 30 | "IsEnabled": true 31 | }, 32 | "func (*List).Back() *Element": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | true, 37 | false 38 | ], 39 | "Outp": [ 40 | false, 41 | true 42 | ] 43 | } 44 | ], 45 | "IsEnabled": true 46 | }, 47 | "func (*List).Front() *Element": { 48 | "Blocks": [ 49 | { 50 | "Inp": [ 51 | true, 52 | false 53 | ], 54 | "Outp": [ 55 | false, 56 | true 57 | ] 58 | } 59 | ], 60 | "IsEnabled": true 61 | }, 62 | "func (*List).Init() *List": { 63 | "Blocks": [ 64 | { 65 | "Inp": [ 66 | true, 67 | false 68 | ], 69 | "Outp": [ 70 | false, 71 | true 72 | ] 73 | } 74 | ], 75 | "IsEnabled": true 76 | }, 77 | "func (*List).InsertAfter(v interface{}, mark *Element) *Element": { 78 | "Blocks": [ 79 | { 80 | "Inp": [ 81 | false, 82 | true, 83 | false, 84 | false 85 | ], 86 | "Outp": [ 87 | true, 88 | false, 89 | false, 90 | true 91 | ] 92 | } 93 | ], 94 | "IsEnabled": true 95 | }, 96 | "func (*List).InsertBefore(v interface{}, mark *Element) *Element": { 97 | "Blocks": [ 98 | { 99 | "Inp": [ 100 | false, 101 | true, 102 | false, 103 | false 104 | ], 105 | "Outp": [ 106 | true, 107 | false, 108 | false, 109 | true 110 | ] 111 | } 112 | ], 113 | "IsEnabled": true 114 | }, 115 | "func (*List).Len() int": { 116 | "Blocks": [ 117 | { 118 | "Inp": [ 119 | false, 120 | false 121 | ], 122 | "Outp": [ 123 | false, 124 | false 125 | ] 126 | } 127 | ], 128 | "IsEnabled": false 129 | }, 130 | "func (*List).MoveAfter(e *Element, mark *Element)": { 131 | "Blocks": [ 132 | { 133 | "Inp": [ 134 | false, 135 | true, 136 | false 137 | ], 138 | "Outp": [ 139 | true, 140 | false, 141 | false 142 | ] 143 | } 144 | ], 145 | "IsEnabled": true 146 | }, 147 | "func (*List).MoveBefore(e *Element, mark *Element)": { 148 | "Blocks": [ 149 | { 150 | "Inp": [ 151 | false, 152 | true, 153 | false 154 | ], 155 | "Outp": [ 156 | true, 157 | false, 158 | false 159 | ] 160 | } 161 | ], 162 | "IsEnabled": true 163 | }, 164 | "func (*List).MoveToBack(e *Element)": { 165 | "Blocks": [ 166 | { 167 | "Inp": [ 168 | false, 169 | true 170 | ], 171 | "Outp": [ 172 | true, 173 | false 174 | ] 175 | } 176 | ], 177 | "IsEnabled": true 178 | }, 179 | "func (*List).MoveToFront(e *Element)": { 180 | "Blocks": [ 181 | { 182 | "Inp": [ 183 | false, 184 | true 185 | ], 186 | "Outp": [ 187 | true, 188 | false 189 | ] 190 | } 191 | ], 192 | "IsEnabled": true 193 | }, 194 | "func (*List).PushBack(v interface{}) *Element": { 195 | "Blocks": [ 196 | { 197 | "Inp": [ 198 | false, 199 | true, 200 | false 201 | ], 202 | "Outp": [ 203 | true, 204 | false, 205 | true 206 | ] 207 | } 208 | ], 209 | "IsEnabled": true 210 | }, 211 | "func (*List).PushBackList(other *List)": { 212 | "Blocks": [ 213 | { 214 | "Inp": [ 215 | false, 216 | true 217 | ], 218 | "Outp": [ 219 | true, 220 | false 221 | ] 222 | } 223 | ], 224 | "IsEnabled": true 225 | }, 226 | "func (*List).PushFront(v interface{}) *Element": { 227 | "Blocks": [ 228 | { 229 | "Inp": [ 230 | false, 231 | true, 232 | false 233 | ], 234 | "Outp": [ 235 | true, 236 | false, 237 | true 238 | ] 239 | } 240 | ], 241 | "IsEnabled": true 242 | }, 243 | "func (*List).PushFrontList(other *List)": { 244 | "Blocks": [ 245 | { 246 | "Inp": [ 247 | false, 248 | true 249 | ], 250 | "Outp": [ 251 | true, 252 | false 253 | ] 254 | } 255 | ], 256 | "IsEnabled": true 257 | }, 258 | "func (*List).Remove(e *Element) interface{}": { 259 | "Blocks": [ 260 | { 261 | "Inp": [ 262 | false, 263 | true, 264 | false 265 | ], 266 | "Outp": [ 267 | false, 268 | false, 269 | true 270 | ] 271 | } 272 | ], 273 | "IsEnabled": true 274 | }, 275 | "func New() *List": { 276 | "Blocks": [ 277 | { 278 | "Inp": [ 279 | false 280 | ], 281 | "Outp": [ 282 | false 283 | ] 284 | } 285 | ], 286 | "IsEnabled": false 287 | } 288 | } 289 | -------------------------------------------------------------------------------- /cache/ContainerRing.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Ring).Do(f func(interface{}))": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*Ring).Len() int": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | false 27 | ] 28 | } 29 | ], 30 | "IsEnabled": false 31 | }, 32 | "func (*Ring).Link(s *Ring) *Ring": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | false, 37 | true, 38 | false 39 | ], 40 | "Outp": [ 41 | false, 42 | false, 43 | true 44 | ] 45 | } 46 | ], 47 | "IsEnabled": true 48 | }, 49 | "func (*Ring).Move(n int) *Ring": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | true, 54 | false, 55 | false 56 | ], 57 | "Outp": [ 58 | false, 59 | false, 60 | true 61 | ] 62 | } 63 | ], 64 | "IsEnabled": true 65 | }, 66 | "func (*Ring).Next() *Ring": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | true, 71 | false 72 | ], 73 | "Outp": [ 74 | false, 75 | true 76 | ] 77 | } 78 | ], 79 | "IsEnabled": true 80 | }, 81 | "func (*Ring).Prev() *Ring": { 82 | "Blocks": [ 83 | { 84 | "Inp": [ 85 | true, 86 | false 87 | ], 88 | "Outp": [ 89 | false, 90 | true 91 | ] 92 | } 93 | ], 94 | "IsEnabled": true 95 | }, 96 | "func (*Ring).Unlink(n int) *Ring": { 97 | "Blocks": [ 98 | { 99 | "Inp": [ 100 | true, 101 | false, 102 | false 103 | ], 104 | "Outp": [ 105 | false, 106 | false, 107 | true 108 | ] 109 | } 110 | ], 111 | "IsEnabled": true 112 | }, 113 | "func New(n int) *Ring": { 114 | "Blocks": [ 115 | { 116 | "Inp": [ 117 | false, 118 | false 119 | ], 120 | "Outp": [ 121 | false, 122 | false 123 | ] 124 | } 125 | ], 126 | "IsEnabled": false 127 | } 128 | } 129 | -------------------------------------------------------------------------------- /cache/Context.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (Context).Deadline() (deadline time.Time, ok bool)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (Context).Done() \u003c-chan struct{}": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | }, 34 | "func (Context).Err() error": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | false, 39 | false 40 | ], 41 | "Outp": [ 42 | false, 43 | false 44 | ] 45 | } 46 | ], 47 | "IsEnabled": false 48 | }, 49 | "func (Context).Value(key interface{}) interface{}": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | true, 54 | false, 55 | false 56 | ], 57 | "Outp": [ 58 | false, 59 | false, 60 | true 61 | ] 62 | } 63 | ], 64 | "IsEnabled": true 65 | }, 66 | "func Background() Context": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | false 71 | ], 72 | "Outp": [ 73 | false 74 | ] 75 | } 76 | ], 77 | "IsEnabled": false 78 | }, 79 | "func TODO() Context": { 80 | "Blocks": [ 81 | { 82 | "Inp": [ 83 | false 84 | ], 85 | "Outp": [ 86 | false 87 | ] 88 | } 89 | ], 90 | "IsEnabled": false 91 | }, 92 | "func WithCancel(parent Context) (ctx Context, cancel CancelFunc)": { 93 | "Blocks": [ 94 | { 95 | "Inp": [ 96 | true, 97 | false, 98 | false 99 | ], 100 | "Outp": [ 101 | false, 102 | true, 103 | false 104 | ] 105 | } 106 | ], 107 | "IsEnabled": true 108 | }, 109 | "func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)": { 110 | "Blocks": [ 111 | { 112 | "Inp": [ 113 | true, 114 | false, 115 | false, 116 | false 117 | ], 118 | "Outp": [ 119 | false, 120 | false, 121 | true, 122 | false 123 | ] 124 | } 125 | ], 126 | "IsEnabled": true 127 | }, 128 | "func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)": { 129 | "Blocks": [ 130 | { 131 | "Inp": [ 132 | true, 133 | false, 134 | false, 135 | false 136 | ], 137 | "Outp": [ 138 | false, 139 | false, 140 | true, 141 | false 142 | ] 143 | } 144 | ], 145 | "IsEnabled": true 146 | }, 147 | "func WithValue(parent Context, key interface{}, val interface{}) Context": { 148 | "Blocks": [ 149 | { 150 | "Inp": [ 151 | true, 152 | true, 153 | true, 154 | false 155 | ], 156 | "Outp": [ 157 | false, 158 | false, 159 | false, 160 | true 161 | ] 162 | } 163 | ], 164 | "IsEnabled": true 165 | } 166 | } 167 | -------------------------------------------------------------------------------- /cache/Crypto.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (Decrypter).Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | true, 9 | false, 10 | false, 11 | false 12 | ], 13 | "Outp": [ 14 | false, 15 | false, 16 | false, 17 | false, 18 | true, 19 | false 20 | ] 21 | } 22 | ], 23 | "IsEnabled": true 24 | }, 25 | "func (Decrypter).Public() PublicKey": { 26 | "Blocks": [ 27 | { 28 | "Inp": [ 29 | false, 30 | false 31 | ], 32 | "Outp": [ 33 | false, 34 | false 35 | ] 36 | } 37 | ], 38 | "IsEnabled": false 39 | }, 40 | "func (Hash).Available() bool": { 41 | "Blocks": [ 42 | { 43 | "Inp": [ 44 | false, 45 | false 46 | ], 47 | "Outp": [ 48 | false, 49 | false 50 | ] 51 | } 52 | ], 53 | "IsEnabled": false 54 | }, 55 | "func (Hash).HashFunc() Hash": { 56 | "Blocks": [ 57 | { 58 | "Inp": [ 59 | false, 60 | false 61 | ], 62 | "Outp": [ 63 | false, 64 | false 65 | ] 66 | } 67 | ], 68 | "IsEnabled": false 69 | }, 70 | "func (Hash).New() hash.Hash": { 71 | "Blocks": [ 72 | { 73 | "Inp": [ 74 | false, 75 | false 76 | ], 77 | "Outp": [ 78 | false, 79 | false 80 | ] 81 | } 82 | ], 83 | "IsEnabled": false 84 | }, 85 | "func (Hash).Size() int": { 86 | "Blocks": [ 87 | { 88 | "Inp": [ 89 | false, 90 | false 91 | ], 92 | "Outp": [ 93 | false, 94 | false 95 | ] 96 | } 97 | ], 98 | "IsEnabled": false 99 | }, 100 | "func (Signer).Public() PublicKey": { 101 | "Blocks": [ 102 | { 103 | "Inp": [ 104 | true, 105 | false 106 | ], 107 | "Outp": [ 108 | false, 109 | true 110 | ] 111 | } 112 | ], 113 | "IsEnabled": false 114 | }, 115 | "func (Signer).Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)": { 116 | "Blocks": [ 117 | { 118 | "Inp": [ 119 | false, 120 | false, 121 | true, 122 | false, 123 | false, 124 | false 125 | ], 126 | "Outp": [ 127 | false, 128 | false, 129 | false, 130 | false, 131 | true, 132 | false 133 | ] 134 | } 135 | ], 136 | "IsEnabled": false 137 | }, 138 | "func (SignerOpts).HashFunc() Hash": { 139 | "Blocks": [ 140 | { 141 | "Inp": [ 142 | false, 143 | false 144 | ], 145 | "Outp": [ 146 | false, 147 | false 148 | ] 149 | } 150 | ], 151 | "IsEnabled": false 152 | }, 153 | "func RegisterHash(h Hash, f func() hash.Hash)": { 154 | "Blocks": [ 155 | { 156 | "Inp": [ 157 | false, 158 | false 159 | ], 160 | "Outp": [ 161 | false, 162 | false 163 | ] 164 | } 165 | ], 166 | "IsEnabled": false 167 | } 168 | } 169 | -------------------------------------------------------------------------------- /cache/CryptoCipher.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (AEAD).NonceSize() int": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (AEAD).Open(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false, 23 | false, 24 | true, 25 | false, 26 | false, 27 | false 28 | ], 29 | "Outp": [ 30 | false, 31 | true, 32 | false, 33 | false, 34 | false, 35 | true, 36 | false 37 | ] 38 | } 39 | ], 40 | "IsEnabled": true 41 | }, 42 | "func (AEAD).Overhead() int": { 43 | "Blocks": [ 44 | { 45 | "Inp": [ 46 | false, 47 | false 48 | ], 49 | "Outp": [ 50 | false, 51 | false 52 | ] 53 | } 54 | ], 55 | "IsEnabled": false 56 | }, 57 | "func (AEAD).Seal(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte": { 58 | "Blocks": [ 59 | { 60 | "Inp": [ 61 | false, 62 | false, 63 | false, 64 | true, 65 | false, 66 | false 67 | ], 68 | "Outp": [ 69 | false, 70 | true, 71 | false, 72 | false, 73 | false, 74 | true 75 | ] 76 | } 77 | ], 78 | "IsEnabled": false 79 | }, 80 | "func (Block).BlockSize() int": { 81 | "Blocks": [ 82 | { 83 | "Inp": [ 84 | false, 85 | false 86 | ], 87 | "Outp": [ 88 | false, 89 | false 90 | ] 91 | } 92 | ], 93 | "IsEnabled": false 94 | }, 95 | "func (Block).Decrypt(dst []byte, src []byte)": { 96 | "Blocks": [ 97 | { 98 | "Inp": [ 99 | false, 100 | false, 101 | true 102 | ], 103 | "Outp": [ 104 | false, 105 | true, 106 | false 107 | ] 108 | } 109 | ], 110 | "IsEnabled": true 111 | }, 112 | "func (Block).Encrypt(dst []byte, src []byte)": { 113 | "Blocks": [ 114 | { 115 | "Inp": [ 116 | false, 117 | false, 118 | true 119 | ], 120 | "Outp": [ 121 | false, 122 | true, 123 | false 124 | ] 125 | } 126 | ], 127 | "IsEnabled": false 128 | }, 129 | "func (BlockMode).BlockSize() int": { 130 | "Blocks": [ 131 | { 132 | "Inp": [ 133 | false, 134 | false 135 | ], 136 | "Outp": [ 137 | false, 138 | false 139 | ] 140 | } 141 | ], 142 | "IsEnabled": false 143 | }, 144 | "func (BlockMode).CryptBlocks(dst []byte, src []byte)": { 145 | "Blocks": [ 146 | { 147 | "Inp": [ 148 | false, 149 | false, 150 | true 151 | ], 152 | "Outp": [ 153 | false, 154 | true, 155 | false 156 | ] 157 | } 158 | ], 159 | "IsEnabled": false 160 | }, 161 | "func (Stream).XORKeyStream(dst []byte, src []byte)": { 162 | "Blocks": [ 163 | { 164 | "Inp": [ 165 | false, 166 | false, 167 | true 168 | ], 169 | "Outp": [ 170 | false, 171 | true, 172 | false 173 | ] 174 | } 175 | ], 176 | "IsEnabled": false 177 | }, 178 | "func (StreamReader).Read(dst []byte) (n int, err error)": { 179 | "Blocks": [ 180 | { 181 | "Inp": [ 182 | true, 183 | false, 184 | false, 185 | false 186 | ], 187 | "Outp": [ 188 | false, 189 | true, 190 | false, 191 | false 192 | ] 193 | } 194 | ], 195 | "IsEnabled": true 196 | }, 197 | "func (StreamWriter).Close() error": { 198 | "Blocks": [ 199 | { 200 | "Inp": [ 201 | false, 202 | false 203 | ], 204 | "Outp": [ 205 | false, 206 | false 207 | ] 208 | } 209 | ], 210 | "IsEnabled": false 211 | }, 212 | "func (StreamWriter).Write(src []byte) (n int, err error)": { 213 | "Blocks": [ 214 | { 215 | "Inp": [ 216 | false, 217 | true, 218 | false, 219 | false 220 | ], 221 | "Outp": [ 222 | true, 223 | false, 224 | false, 225 | false 226 | ] 227 | } 228 | ], 229 | "IsEnabled": true 230 | }, 231 | "func NewCBCDecrypter(b Block, iv []byte) BlockMode": { 232 | "Blocks": [ 233 | { 234 | "Inp": [ 235 | false, 236 | false, 237 | false 238 | ], 239 | "Outp": [ 240 | false, 241 | false, 242 | false 243 | ] 244 | } 245 | ], 246 | "IsEnabled": false 247 | }, 248 | "func NewCBCEncrypter(b Block, iv []byte) BlockMode": { 249 | "Blocks": [ 250 | { 251 | "Inp": [ 252 | false, 253 | false, 254 | false 255 | ], 256 | "Outp": [ 257 | false, 258 | false, 259 | false 260 | ] 261 | } 262 | ], 263 | "IsEnabled": false 264 | }, 265 | "func NewCFBDecrypter(block Block, iv []byte) Stream": { 266 | "Blocks": [ 267 | { 268 | "Inp": [ 269 | false, 270 | false, 271 | false 272 | ], 273 | "Outp": [ 274 | false, 275 | false, 276 | false 277 | ] 278 | } 279 | ], 280 | "IsEnabled": false 281 | }, 282 | "func NewCFBEncrypter(block Block, iv []byte) Stream": { 283 | "Blocks": [ 284 | { 285 | "Inp": [ 286 | false, 287 | false, 288 | false 289 | ], 290 | "Outp": [ 291 | false, 292 | false, 293 | false 294 | ] 295 | } 296 | ], 297 | "IsEnabled": false 298 | }, 299 | "func NewCTR(block Block, iv []byte) Stream": { 300 | "Blocks": [ 301 | { 302 | "Inp": [ 303 | false, 304 | false, 305 | false 306 | ], 307 | "Outp": [ 308 | false, 309 | false, 310 | false 311 | ] 312 | } 313 | ], 314 | "IsEnabled": false 315 | }, 316 | "func NewGCM(cipher Block) (AEAD, error)": { 317 | "Blocks": [ 318 | { 319 | "Inp": [ 320 | false, 321 | false, 322 | false 323 | ], 324 | "Outp": [ 325 | false, 326 | false, 327 | false 328 | ] 329 | } 330 | ], 331 | "IsEnabled": false 332 | }, 333 | "func NewGCMWithNonceSize(cipher Block, size int) (AEAD, error)": { 334 | "Blocks": [ 335 | { 336 | "Inp": [ 337 | false, 338 | false, 339 | false, 340 | false 341 | ], 342 | "Outp": [ 343 | false, 344 | false, 345 | false, 346 | false 347 | ] 348 | } 349 | ], 350 | "IsEnabled": false 351 | }, 352 | "func NewGCMWithTagSize(cipher Block, tagSize int) (AEAD, error)": { 353 | "Blocks": [ 354 | { 355 | "Inp": [ 356 | false, 357 | false, 358 | false, 359 | false 360 | ], 361 | "Outp": [ 362 | false, 363 | false, 364 | false, 365 | false 366 | ] 367 | } 368 | ], 369 | "IsEnabled": false 370 | }, 371 | "func NewOFB(b Block, iv []byte) Stream": { 372 | "Blocks": [ 373 | { 374 | "Inp": [ 375 | false, 376 | false, 377 | false 378 | ], 379 | "Outp": [ 380 | false, 381 | false, 382 | false 383 | ] 384 | } 385 | ], 386 | "IsEnabled": false 387 | } 388 | } 389 | -------------------------------------------------------------------------------- /cache/CryptoEcdsa.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*PrivateKey).Public() crypto.PublicKey": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*PrivateKey).Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false, 23 | true, 24 | false, 25 | false, 26 | false 27 | ], 28 | "Outp": [ 29 | false, 30 | false, 31 | false, 32 | false, 33 | true, 34 | false 35 | ] 36 | } 37 | ], 38 | "IsEnabled": false 39 | }, 40 | "func GenerateKey(c crypto/elliptic.Curve, rand io.Reader) (*PrivateKey, error)": { 41 | "Blocks": [ 42 | { 43 | "Inp": [ 44 | false, 45 | false, 46 | false, 47 | false 48 | ], 49 | "Outp": [ 50 | false, 51 | false, 52 | false, 53 | false 54 | ] 55 | } 56 | ], 57 | "IsEnabled": false 58 | }, 59 | "func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r *math/big.Int, s *math/big.Int, err error)": { 60 | "Blocks": [ 61 | { 62 | "Inp": [ 63 | false, 64 | false, 65 | false, 66 | false, 67 | false, 68 | false 69 | ], 70 | "Outp": [ 71 | false, 72 | false, 73 | false, 74 | false, 75 | false, 76 | false 77 | ] 78 | } 79 | ], 80 | "IsEnabled": false 81 | }, 82 | "func Verify(pub *PublicKey, hash []byte, r *math/big.Int, s *math/big.Int) bool": { 83 | "Blocks": [ 84 | { 85 | "Inp": [ 86 | false, 87 | false, 88 | false, 89 | false, 90 | false 91 | ], 92 | "Outp": [ 93 | false, 94 | false, 95 | false, 96 | false, 97 | false 98 | ] 99 | } 100 | ], 101 | "IsEnabled": false 102 | } 103 | } 104 | -------------------------------------------------------------------------------- /cache/CryptoEd25519.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (PrivateKey).Public() crypto.PublicKey": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (PrivateKey).Seed() []byte": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | false 27 | ] 28 | } 29 | ], 30 | "IsEnabled": false 31 | }, 32 | "func (PrivateKey).Sign(rand io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error)": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | false, 37 | false, 38 | true, 39 | false, 40 | false, 41 | false 42 | ], 43 | "Outp": [ 44 | false, 45 | false, 46 | false, 47 | false, 48 | true, 49 | false 50 | ] 51 | } 52 | ], 53 | "IsEnabled": false 54 | }, 55 | "func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error)": { 56 | "Blocks": [ 57 | { 58 | "Inp": [ 59 | false, 60 | false, 61 | false, 62 | false 63 | ], 64 | "Outp": [ 65 | false, 66 | false, 67 | false, 68 | false 69 | ] 70 | } 71 | ], 72 | "IsEnabled": false 73 | }, 74 | "func NewKeyFromSeed(seed []byte) PrivateKey": { 75 | "Blocks": [ 76 | { 77 | "Inp": [ 78 | false, 79 | false 80 | ], 81 | "Outp": [ 82 | false, 83 | false 84 | ] 85 | } 86 | ], 87 | "IsEnabled": false 88 | }, 89 | "func Sign(privateKey PrivateKey, message []byte) []byte": { 90 | "Blocks": [ 91 | { 92 | "Inp": [ 93 | false, 94 | true, 95 | false 96 | ], 97 | "Outp": [ 98 | false, 99 | false, 100 | true 101 | ] 102 | } 103 | ], 104 | "IsEnabled": false 105 | }, 106 | "func Verify(publicKey PublicKey, message []byte, sig []byte) bool": { 107 | "Blocks": [ 108 | { 109 | "Inp": [ 110 | false, 111 | false, 112 | false, 113 | false 114 | ], 115 | "Outp": [ 116 | false, 117 | false, 118 | false, 119 | false 120 | ] 121 | } 122 | ], 123 | "IsEnabled": false 124 | } 125 | } 126 | -------------------------------------------------------------------------------- /cache/CryptoRsa.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*PSSOptions).HashFunc() crypto.Hash": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*PrivateKey).Decrypt(rand io.Reader, ciphertext []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false, 23 | true, 24 | false, 25 | false, 26 | false 27 | ], 28 | "Outp": [ 29 | false, 30 | false, 31 | false, 32 | false, 33 | true, 34 | false 35 | ] 36 | } 37 | ], 38 | "IsEnabled": true 39 | }, 40 | "func (*PrivateKey).Precompute()": { 41 | "Blocks": [ 42 | { 43 | "Inp": [ 44 | false 45 | ], 46 | "Outp": [ 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": false 52 | }, 53 | "func (*PrivateKey).Public() crypto.PublicKey": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | false 59 | ], 60 | "Outp": [ 61 | false, 62 | false 63 | ] 64 | } 65 | ], 66 | "IsEnabled": false 67 | }, 68 | "func (*PrivateKey).Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error)": { 69 | "Blocks": [ 70 | { 71 | "Inp": [ 72 | false, 73 | false, 74 | true, 75 | false, 76 | false, 77 | false 78 | ], 79 | "Outp": [ 80 | false, 81 | false, 82 | false, 83 | false, 84 | true, 85 | false 86 | ] 87 | } 88 | ], 89 | "IsEnabled": false 90 | }, 91 | "func (*PrivateKey).Validate() error": { 92 | "Blocks": [ 93 | { 94 | "Inp": [ 95 | false, 96 | false 97 | ], 98 | "Outp": [ 99 | false, 100 | false 101 | ] 102 | } 103 | ], 104 | "IsEnabled": false 105 | }, 106 | "func (*PublicKey).Size() int": { 107 | "Blocks": [ 108 | { 109 | "Inp": [ 110 | false, 111 | false 112 | ], 113 | "Outp": [ 114 | false, 115 | false 116 | ] 117 | } 118 | ], 119 | "IsEnabled": false 120 | }, 121 | "func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error)": { 122 | "Blocks": [ 123 | { 124 | "Inp": [ 125 | false, 126 | false, 127 | false, 128 | true, 129 | false, 130 | false, 131 | false 132 | ], 133 | "Outp": [ 134 | false, 135 | false, 136 | false, 137 | false, 138 | false, 139 | true, 140 | false 141 | ] 142 | } 143 | ], 144 | "IsEnabled": true 145 | }, 146 | "func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error)": { 147 | "Blocks": [ 148 | { 149 | "Inp": [ 150 | false, 151 | false, 152 | true, 153 | false, 154 | false 155 | ], 156 | "Outp": [ 157 | false, 158 | false, 159 | false, 160 | true, 161 | false 162 | ] 163 | } 164 | ], 165 | "IsEnabled": true 166 | }, 167 | "func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error": { 168 | "Blocks": [ 169 | { 170 | "Inp": [ 171 | false, 172 | false, 173 | true, 174 | false, 175 | false 176 | ], 177 | "Outp": [ 178 | false, 179 | false, 180 | false, 181 | true, 182 | false 183 | ] 184 | } 185 | ], 186 | "IsEnabled": false 187 | }, 188 | "func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error)": { 189 | "Blocks": [ 190 | { 191 | "Inp": [ 192 | false, 193 | false, 194 | false, 195 | true, 196 | false, 197 | false, 198 | false 199 | ], 200 | "Outp": [ 201 | false, 202 | false, 203 | false, 204 | false, 205 | false, 206 | true, 207 | false 208 | ] 209 | } 210 | ], 211 | "IsEnabled": false 212 | }, 213 | "func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) ([]byte, error)": { 214 | "Blocks": [ 215 | { 216 | "Inp": [ 217 | false, 218 | false, 219 | true, 220 | false, 221 | false 222 | ], 223 | "Outp": [ 224 | false, 225 | false, 226 | false, 227 | true, 228 | false 229 | ] 230 | } 231 | ], 232 | "IsEnabled": false 233 | }, 234 | "func GenerateKey(random io.Reader, bits int) (*PrivateKey, error)": { 235 | "Blocks": [ 236 | { 237 | "Inp": [ 238 | false, 239 | false, 240 | false, 241 | false 242 | ], 243 | "Outp": [ 244 | false, 245 | false, 246 | false, 247 | false 248 | ] 249 | } 250 | ], 251 | "IsEnabled": false 252 | }, 253 | "func GenerateMultiPrimeKey(random io.Reader, nprimes int, bits int) (*PrivateKey, error)": { 254 | "Blocks": [ 255 | { 256 | "Inp": [ 257 | false, 258 | false, 259 | false, 260 | false, 261 | false 262 | ], 263 | "Outp": [ 264 | false, 265 | false, 266 | false, 267 | false, 268 | false 269 | ] 270 | } 271 | ], 272 | "IsEnabled": false 273 | }, 274 | "func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)": { 275 | "Blocks": [ 276 | { 277 | "Inp": [ 278 | false, 279 | false, 280 | false, 281 | true, 282 | false, 283 | false 284 | ], 285 | "Outp": [ 286 | false, 287 | false, 288 | false, 289 | false, 290 | true, 291 | false 292 | ] 293 | } 294 | ], 295 | "IsEnabled": false 296 | }, 297 | "func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte, opts *PSSOptions) ([]byte, error)": { 298 | "Blocks": [ 299 | { 300 | "Inp": [ 301 | false, 302 | false, 303 | false, 304 | true, 305 | false, 306 | false, 307 | false 308 | ], 309 | "Outp": [ 310 | false, 311 | false, 312 | false, 313 | false, 314 | false, 315 | true, 316 | false 317 | ] 318 | } 319 | ], 320 | "IsEnabled": false 321 | }, 322 | "func VerifyPKCS1v15(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error": { 323 | "Blocks": [ 324 | { 325 | "Inp": [ 326 | false, 327 | false, 328 | false, 329 | false, 330 | false 331 | ], 332 | "Outp": [ 333 | false, 334 | false, 335 | false, 336 | false, 337 | false 338 | ] 339 | } 340 | ], 341 | "IsEnabled": false 342 | }, 343 | "func VerifyPSS(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte, opts *PSSOptions) error": { 344 | "Blocks": [ 345 | { 346 | "Inp": [ 347 | false, 348 | false, 349 | false, 350 | false, 351 | false, 352 | false 353 | ], 354 | "Outp": [ 355 | false, 356 | false, 357 | false, 358 | false, 359 | false, 360 | false 361 | ] 362 | } 363 | ], 364 | "IsEnabled": false 365 | } 366 | } 367 | -------------------------------------------------------------------------------- /cache/Encoding.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (BinaryMarshaler).MarshalBinary() (data []byte, err error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": true 18 | }, 19 | "func (BinaryUnmarshaler).UnmarshalBinary(data []byte) error": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | true, 25 | false 26 | ], 27 | "Outp": [ 28 | true, 29 | false, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": true 35 | }, 36 | "func (TextMarshaler).MarshalText() (text []byte, err error)": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | true, 41 | false, 42 | false 43 | ], 44 | "Outp": [ 45 | false, 46 | true, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": true 52 | }, 53 | "func (TextUnmarshaler).UnmarshalText(text []byte) error": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | true, 59 | false 60 | ], 61 | "Outp": [ 62 | true, 63 | false, 64 | false 65 | ] 66 | } 67 | ], 68 | "IsEnabled": true 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /cache/EncodingAscii85.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (CorruptInputError).Error() string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func Decode(dst []byte, src []byte, flush bool) (ndst int, nsrc int, err error)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | true, 23 | false, 24 | false, 25 | false, 26 | false 27 | ], 28 | "Outp": [ 29 | true, 30 | false, 31 | false, 32 | false, 33 | false, 34 | false 35 | ] 36 | } 37 | ], 38 | "IsEnabled": true 39 | }, 40 | "func Encode(dst []byte, src []byte) int": { 41 | "Blocks": [ 42 | { 43 | "Inp": [ 44 | false, 45 | true, 46 | false 47 | ], 48 | "Outp": [ 49 | true, 50 | false, 51 | false 52 | ] 53 | } 54 | ], 55 | "IsEnabled": false 56 | }, 57 | "func MaxEncodedLen(n int) int": { 58 | "Blocks": [ 59 | { 60 | "Inp": [ 61 | false, 62 | false 63 | ], 64 | "Outp": [ 65 | false, 66 | false 67 | ] 68 | } 69 | ], 70 | "IsEnabled": false 71 | }, 72 | "func NewDecoder(r io.Reader) io.Reader": { 73 | "Blocks": [ 74 | { 75 | "Inp": [ 76 | true, 77 | false 78 | ], 79 | "Outp": [ 80 | false, 81 | true 82 | ] 83 | } 84 | ], 85 | "IsEnabled": true 86 | }, 87 | "func NewEncoder(w io.Writer) io.WriteCloser": { 88 | "Blocks": [ 89 | { 90 | "Inp": [ 91 | false, 92 | true 93 | ], 94 | "Outp": [ 95 | true, 96 | false 97 | ] 98 | } 99 | ], 100 | "IsEnabled": false 101 | } 102 | } 103 | -------------------------------------------------------------------------------- /cache/EncodingAsn1.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (BitString).At(i int) int": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (BitString).RightAlign() []byte": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | }, 34 | "func (ObjectIdentifier).Equal(other ObjectIdentifier) bool": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | false, 39 | false, 40 | false 41 | ], 42 | "Outp": [ 43 | false, 44 | false, 45 | false 46 | ] 47 | } 48 | ], 49 | "IsEnabled": false 50 | }, 51 | "func (ObjectIdentifier).String() string": { 52 | "Blocks": [ 53 | { 54 | "Inp": [ 55 | true, 56 | false 57 | ], 58 | "Outp": [ 59 | false, 60 | true 61 | ] 62 | } 63 | ], 64 | "IsEnabled": false 65 | }, 66 | "func (StructuralError).Error() string": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | false, 71 | false 72 | ], 73 | "Outp": [ 74 | false, 75 | false 76 | ] 77 | } 78 | ], 79 | "IsEnabled": false 80 | }, 81 | "func (SyntaxError).Error() string": { 82 | "Blocks": [ 83 | { 84 | "Inp": [ 85 | false, 86 | false 87 | ], 88 | "Outp": [ 89 | false, 90 | false 91 | ] 92 | } 93 | ], 94 | "IsEnabled": false 95 | }, 96 | "func Marshal(val interface{}) ([]byte, error)": { 97 | "Blocks": [ 98 | { 99 | "Inp": [ 100 | true, 101 | false, 102 | false 103 | ], 104 | "Outp": [ 105 | false, 106 | true, 107 | false 108 | ] 109 | } 110 | ], 111 | "IsEnabled": true 112 | }, 113 | "func MarshalWithParams(val interface{}, params string) ([]byte, error)": { 114 | "Blocks": [ 115 | { 116 | "Inp": [ 117 | true, 118 | true, 119 | false, 120 | false 121 | ], 122 | "Outp": [ 123 | false, 124 | false, 125 | true, 126 | false 127 | ] 128 | } 129 | ], 130 | "IsEnabled": true 131 | }, 132 | "func Unmarshal(b []byte, val interface{}) (rest []byte, err error)": { 133 | "Blocks": [ 134 | { 135 | "Inp": [ 136 | true, 137 | false, 138 | false, 139 | false 140 | ], 141 | "Outp": [ 142 | false, 143 | true, 144 | true, 145 | false 146 | ] 147 | } 148 | ], 149 | "IsEnabled": true 150 | }, 151 | "func UnmarshalWithParams(b []byte, val interface{}, params string) (rest []byte, err error)": { 152 | "Blocks": [ 153 | { 154 | "Inp": [ 155 | true, 156 | false, 157 | true, 158 | false, 159 | false 160 | ], 161 | "Outp": [ 162 | false, 163 | true, 164 | false, 165 | true, 166 | false 167 | ] 168 | } 169 | ], 170 | "IsEnabled": true 171 | } 172 | } 173 | -------------------------------------------------------------------------------- /cache/EncodingBase32.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Encoding).Decode(dst []byte, src []byte) (n int, err error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | true, 9 | false, 10 | false 11 | ], 12 | "Outp": [ 13 | false, 14 | true, 15 | false, 16 | false, 17 | false 18 | ] 19 | } 20 | ], 21 | "IsEnabled": true 22 | }, 23 | "func (*Encoding).DecodeString(s string) ([]byte, error)": { 24 | "Blocks": [ 25 | { 26 | "Inp": [ 27 | false, 28 | true, 29 | false, 30 | false 31 | ], 32 | "Outp": [ 33 | false, 34 | false, 35 | true, 36 | false 37 | ] 38 | } 39 | ], 40 | "IsEnabled": true 41 | }, 42 | "func (*Encoding).DecodedLen(n int) int": { 43 | "Blocks": [ 44 | { 45 | "Inp": [ 46 | false, 47 | false, 48 | false 49 | ], 50 | "Outp": [ 51 | false, 52 | false, 53 | false 54 | ] 55 | } 56 | ], 57 | "IsEnabled": false 58 | }, 59 | "func (*Encoding).Encode(dst []byte, src []byte)": { 60 | "Blocks": [ 61 | { 62 | "Inp": [ 63 | false, 64 | false, 65 | true 66 | ], 67 | "Outp": [ 68 | false, 69 | true, 70 | false 71 | ] 72 | } 73 | ], 74 | "IsEnabled": false 75 | }, 76 | "func (*Encoding).EncodeToString(src []byte) string": { 77 | "Blocks": [ 78 | { 79 | "Inp": [ 80 | false, 81 | true, 82 | false 83 | ], 84 | "Outp": [ 85 | false, 86 | false, 87 | true 88 | ] 89 | } 90 | ], 91 | "IsEnabled": false 92 | }, 93 | "func (*Encoding).EncodedLen(n int) int": { 94 | "Blocks": [ 95 | { 96 | "Inp": [ 97 | false, 98 | false, 99 | false 100 | ], 101 | "Outp": [ 102 | false, 103 | false, 104 | false 105 | ] 106 | } 107 | ], 108 | "IsEnabled": false 109 | }, 110 | "func (CorruptInputError).Error() string": { 111 | "Blocks": [ 112 | { 113 | "Inp": [ 114 | false, 115 | false 116 | ], 117 | "Outp": [ 118 | false, 119 | false 120 | ] 121 | } 122 | ], 123 | "IsEnabled": false 124 | }, 125 | "func (Encoding).WithPadding(padding rune) *Encoding": { 126 | "Blocks": [ 127 | { 128 | "Inp": [ 129 | false, 130 | false, 131 | false 132 | ], 133 | "Outp": [ 134 | false, 135 | false, 136 | false 137 | ] 138 | } 139 | ], 140 | "IsEnabled": false 141 | }, 142 | "func NewDecoder(enc *Encoding, r io.Reader) io.Reader": { 143 | "Blocks": [ 144 | { 145 | "Inp": [ 146 | false, 147 | true, 148 | false 149 | ], 150 | "Outp": [ 151 | false, 152 | false, 153 | true 154 | ] 155 | } 156 | ], 157 | "IsEnabled": true 158 | }, 159 | "func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser": { 160 | "Blocks": [ 161 | { 162 | "Inp": [ 163 | false, 164 | false, 165 | true 166 | ], 167 | "Outp": [ 168 | false, 169 | true, 170 | false 171 | ] 172 | } 173 | ], 174 | "IsEnabled": false 175 | }, 176 | "func NewEncoding(encoder string) *Encoding": { 177 | "Blocks": [ 178 | { 179 | "Inp": [ 180 | false, 181 | false 182 | ], 183 | "Outp": [ 184 | false, 185 | false 186 | ] 187 | } 188 | ], 189 | "IsEnabled": false 190 | } 191 | } 192 | -------------------------------------------------------------------------------- /cache/EncodingBase64.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Encoding).Decode(dst []byte, src []byte) (n int, err error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | true, 9 | false, 10 | false 11 | ], 12 | "Outp": [ 13 | false, 14 | true, 15 | false, 16 | false, 17 | false 18 | ] 19 | } 20 | ], 21 | "IsEnabled": true 22 | }, 23 | "func (*Encoding).DecodeString(s string) ([]byte, error)": { 24 | "Blocks": [ 25 | { 26 | "Inp": [ 27 | false, 28 | true, 29 | false, 30 | false 31 | ], 32 | "Outp": [ 33 | false, 34 | false, 35 | true, 36 | false 37 | ] 38 | } 39 | ], 40 | "IsEnabled": true 41 | }, 42 | "func (*Encoding).DecodedLen(n int) int": { 43 | "Blocks": [ 44 | { 45 | "Inp": [ 46 | false, 47 | false, 48 | false 49 | ], 50 | "Outp": [ 51 | false, 52 | false, 53 | false 54 | ] 55 | } 56 | ], 57 | "IsEnabled": false 58 | }, 59 | "func (*Encoding).Encode(dst []byte, src []byte)": { 60 | "Blocks": [ 61 | { 62 | "Inp": [ 63 | false, 64 | false, 65 | true 66 | ], 67 | "Outp": [ 68 | false, 69 | true, 70 | false 71 | ] 72 | } 73 | ], 74 | "IsEnabled": false 75 | }, 76 | "func (*Encoding).EncodeToString(src []byte) string": { 77 | "Blocks": [ 78 | { 79 | "Inp": [ 80 | false, 81 | true, 82 | false 83 | ], 84 | "Outp": [ 85 | false, 86 | false, 87 | true 88 | ] 89 | } 90 | ], 91 | "IsEnabled": false 92 | }, 93 | "func (*Encoding).EncodedLen(n int) int": { 94 | "Blocks": [ 95 | { 96 | "Inp": [ 97 | false, 98 | false, 99 | false 100 | ], 101 | "Outp": [ 102 | false, 103 | false, 104 | false 105 | ] 106 | } 107 | ], 108 | "IsEnabled": false 109 | }, 110 | "func (CorruptInputError).Error() string": { 111 | "Blocks": [ 112 | { 113 | "Inp": [ 114 | false, 115 | false 116 | ], 117 | "Outp": [ 118 | false, 119 | false 120 | ] 121 | } 122 | ], 123 | "IsEnabled": false 124 | }, 125 | "func (Encoding).Strict() *Encoding": { 126 | "Blocks": [ 127 | { 128 | "Inp": [ 129 | false, 130 | false 131 | ], 132 | "Outp": [ 133 | false, 134 | false 135 | ] 136 | } 137 | ], 138 | "IsEnabled": false 139 | }, 140 | "func (Encoding).WithPadding(padding rune) *Encoding": { 141 | "Blocks": [ 142 | { 143 | "Inp": [ 144 | false, 145 | false, 146 | false 147 | ], 148 | "Outp": [ 149 | false, 150 | false, 151 | false 152 | ] 153 | } 154 | ], 155 | "IsEnabled": false 156 | }, 157 | "func NewDecoder(enc *Encoding, r io.Reader) io.Reader": { 158 | "Blocks": [ 159 | { 160 | "Inp": [ 161 | false, 162 | true, 163 | false 164 | ], 165 | "Outp": [ 166 | false, 167 | false, 168 | true 169 | ] 170 | } 171 | ], 172 | "IsEnabled": true 173 | }, 174 | "func NewEncoder(enc *Encoding, w io.Writer) io.WriteCloser": { 175 | "Blocks": [ 176 | { 177 | "Inp": [ 178 | false, 179 | false, 180 | true 181 | ], 182 | "Outp": [ 183 | false, 184 | true, 185 | false 186 | ] 187 | } 188 | ], 189 | "IsEnabled": false 190 | }, 191 | "func NewEncoding(encoder string) *Encoding": { 192 | "Blocks": [ 193 | { 194 | "Inp": [ 195 | false, 196 | false 197 | ], 198 | "Outp": [ 199 | false, 200 | false 201 | ] 202 | } 203 | ], 204 | "IsEnabled": false 205 | } 206 | } 207 | -------------------------------------------------------------------------------- /cache/EncodingBinary.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (ByteOrder).PutUint16([]byte, uint16)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | true 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (ByteOrder).PutUint32([]byte, uint32)": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false, 25 | true 26 | ], 27 | "Outp": [ 28 | false, 29 | true, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": false 35 | }, 36 | "func (ByteOrder).PutUint64([]byte, uint64)": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | false, 41 | false, 42 | true 43 | ], 44 | "Outp": [ 45 | false, 46 | true, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": false 52 | }, 53 | "func (ByteOrder).String() string": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | true, 58 | false 59 | ], 60 | "Outp": [ 61 | false, 62 | true 63 | ] 64 | } 65 | ], 66 | "IsEnabled": false 67 | }, 68 | "func (ByteOrder).Uint16([]byte) uint16": { 69 | "Blocks": [ 70 | { 71 | "Inp": [ 72 | false, 73 | true, 74 | false 75 | ], 76 | "Outp": [ 77 | false, 78 | false, 79 | true 80 | ] 81 | } 82 | ], 83 | "IsEnabled": false 84 | }, 85 | "func (ByteOrder).Uint32([]byte) uint32": { 86 | "Blocks": [ 87 | { 88 | "Inp": [ 89 | false, 90 | true, 91 | false 92 | ], 93 | "Outp": [ 94 | false, 95 | false, 96 | true 97 | ] 98 | } 99 | ], 100 | "IsEnabled": false 101 | }, 102 | "func (ByteOrder).Uint64([]byte) uint64": { 103 | "Blocks": [ 104 | { 105 | "Inp": [ 106 | false, 107 | true, 108 | false 109 | ], 110 | "Outp": [ 111 | false, 112 | false, 113 | true 114 | ] 115 | } 116 | ], 117 | "IsEnabled": false 118 | }, 119 | "func PutUvarint(buf []byte, x uint64) int": { 120 | "Blocks": [ 121 | { 122 | "Inp": [ 123 | false, 124 | true, 125 | false 126 | ], 127 | "Outp": [ 128 | true, 129 | false, 130 | false 131 | ] 132 | } 133 | ], 134 | "IsEnabled": false 135 | }, 136 | "func PutVarint(buf []byte, x int64) int": { 137 | "Blocks": [ 138 | { 139 | "Inp": [ 140 | false, 141 | true, 142 | false 143 | ], 144 | "Outp": [ 145 | true, 146 | false, 147 | false 148 | ] 149 | } 150 | ], 151 | "IsEnabled": false 152 | }, 153 | "func Read(r io.Reader, order ByteOrder, data interface{}) error": { 154 | "Blocks": [ 155 | { 156 | "Inp": [ 157 | true, 158 | false, 159 | false, 160 | false 161 | ], 162 | "Outp": [ 163 | false, 164 | false, 165 | true, 166 | false 167 | ] 168 | } 169 | ], 170 | "IsEnabled": true 171 | }, 172 | "func ReadUvarint(r io.ByteReader) (uint64, error)": { 173 | "Blocks": [ 174 | { 175 | "Inp": [ 176 | true, 177 | false, 178 | false 179 | ], 180 | "Outp": [ 181 | false, 182 | true, 183 | false 184 | ] 185 | } 186 | ], 187 | "IsEnabled": false 188 | }, 189 | "func ReadVarint(r io.ByteReader) (int64, error)": { 190 | "Blocks": [ 191 | { 192 | "Inp": [ 193 | true, 194 | false, 195 | false 196 | ], 197 | "Outp": [ 198 | false, 199 | true, 200 | false 201 | ] 202 | } 203 | ], 204 | "IsEnabled": false 205 | }, 206 | "func Size(v interface{}) int": { 207 | "Blocks": [ 208 | { 209 | "Inp": [ 210 | false, 211 | false 212 | ], 213 | "Outp": [ 214 | false, 215 | false 216 | ] 217 | } 218 | ], 219 | "IsEnabled": false 220 | }, 221 | "func Uvarint(buf []byte) (uint64, int)": { 222 | "Blocks": [ 223 | { 224 | "Inp": [ 225 | true, 226 | false, 227 | false 228 | ], 229 | "Outp": [ 230 | false, 231 | true, 232 | false 233 | ] 234 | } 235 | ], 236 | "IsEnabled": false 237 | }, 238 | "func Varint(buf []byte) (int64, int)": { 239 | "Blocks": [ 240 | { 241 | "Inp": [ 242 | true, 243 | false, 244 | false 245 | ], 246 | "Outp": [ 247 | false, 248 | true, 249 | false 250 | ] 251 | } 252 | ], 253 | "IsEnabled": false 254 | }, 255 | "func Write(w io.Writer, order ByteOrder, data interface{}) error": { 256 | "Blocks": [ 257 | { 258 | "Inp": [ 259 | false, 260 | false, 261 | true, 262 | false 263 | ], 264 | "Outp": [ 265 | true, 266 | false, 267 | false, 268 | false 269 | ] 270 | } 271 | ], 272 | "IsEnabled": true 273 | } 274 | } 275 | -------------------------------------------------------------------------------- /cache/EncodingCsv.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*ParseError).Error() string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*ParseError).Unwrap() error": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | false 27 | ] 28 | } 29 | ], 30 | "IsEnabled": false 31 | }, 32 | "func (*Reader).Read() (record []string, err error)": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | true, 37 | false, 38 | false 39 | ], 40 | "Outp": [ 41 | false, 42 | true, 43 | false 44 | ] 45 | } 46 | ], 47 | "IsEnabled": true 48 | }, 49 | "func (*Reader).ReadAll() (records [][]string, err error)": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | true, 54 | false, 55 | false 56 | ], 57 | "Outp": [ 58 | false, 59 | true, 60 | false 61 | ] 62 | } 63 | ], 64 | "IsEnabled": true 65 | }, 66 | "func (*Writer).Error() error": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | false, 71 | false 72 | ], 73 | "Outp": [ 74 | false, 75 | false 76 | ] 77 | } 78 | ], 79 | "IsEnabled": false 80 | }, 81 | "func (*Writer).Flush()": { 82 | "Blocks": [ 83 | { 84 | "Inp": [ 85 | false 86 | ], 87 | "Outp": [ 88 | false 89 | ] 90 | } 91 | ], 92 | "IsEnabled": false 93 | }, 94 | "func (*Writer).Write(record []string) error": { 95 | "Blocks": [ 96 | { 97 | "Inp": [ 98 | false, 99 | true, 100 | false 101 | ], 102 | "Outp": [ 103 | true, 104 | false, 105 | false 106 | ] 107 | } 108 | ], 109 | "IsEnabled": true 110 | }, 111 | "func (*Writer).WriteAll(records [][]string) error": { 112 | "Blocks": [ 113 | { 114 | "Inp": [ 115 | false, 116 | true, 117 | false 118 | ], 119 | "Outp": [ 120 | true, 121 | false, 122 | false 123 | ] 124 | } 125 | ], 126 | "IsEnabled": true 127 | }, 128 | "func NewReader(r io.Reader) *Reader": { 129 | "Blocks": [ 130 | { 131 | "Inp": [ 132 | true, 133 | false 134 | ], 135 | "Outp": [ 136 | false, 137 | true 138 | ] 139 | } 140 | ], 141 | "IsEnabled": true 142 | }, 143 | "func NewWriter(w io.Writer) *Writer": { 144 | "Blocks": [ 145 | { 146 | "Inp": [ 147 | false, 148 | true 149 | ], 150 | "Outp": [ 151 | true, 152 | false 153 | ] 154 | } 155 | ], 156 | "IsEnabled": true 157 | } 158 | } 159 | -------------------------------------------------------------------------------- /cache/EncodingGob.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Decoder).Decode(e interface{}) error": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": true 18 | }, 19 | "func (*Decoder).DecodeValue(v reflect.Value) error": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | true, 24 | false, 25 | false 26 | ], 27 | "Outp": [ 28 | false, 29 | true, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": true 35 | }, 36 | "func (*Encoder).Encode(e interface{}) error": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | false, 41 | true, 42 | false 43 | ], 44 | "Outp": [ 45 | true, 46 | false, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": true 52 | }, 53 | "func (*Encoder).EncodeValue(value reflect.Value) error": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | true, 59 | false 60 | ], 61 | "Outp": [ 62 | true, 63 | false, 64 | false 65 | ] 66 | } 67 | ], 68 | "IsEnabled": true 69 | }, 70 | "func (GobDecoder).GobDecode([]byte) error": { 71 | "Blocks": [ 72 | { 73 | "Inp": [ 74 | false, 75 | true, 76 | false 77 | ], 78 | "Outp": [ 79 | true, 80 | false, 81 | false 82 | ] 83 | } 84 | ], 85 | "IsEnabled": true 86 | }, 87 | "func (GobEncoder).GobEncode() ([]byte, error)": { 88 | "Blocks": [ 89 | { 90 | "Inp": [ 91 | true, 92 | false, 93 | false 94 | ], 95 | "Outp": [ 96 | false, 97 | true, 98 | false 99 | ] 100 | } 101 | ], 102 | "IsEnabled": true 103 | }, 104 | "func NewDecoder(r io.Reader) *Decoder": { 105 | "Blocks": [ 106 | { 107 | "Inp": [ 108 | true, 109 | false 110 | ], 111 | "Outp": [ 112 | false, 113 | true 114 | ] 115 | } 116 | ], 117 | "IsEnabled": true 118 | }, 119 | "func NewEncoder(w io.Writer) *Encoder": { 120 | "Blocks": [ 121 | { 122 | "Inp": [ 123 | false, 124 | true 125 | ], 126 | "Outp": [ 127 | true, 128 | false 129 | ] 130 | } 131 | ], 132 | "IsEnabled": true 133 | }, 134 | "func Register(value interface{})": { 135 | "Blocks": [ 136 | { 137 | "Inp": [ 138 | false 139 | ], 140 | "Outp": [ 141 | false 142 | ] 143 | } 144 | ], 145 | "IsEnabled": false 146 | }, 147 | "func RegisterName(name string, value interface{})": { 148 | "Blocks": [ 149 | { 150 | "Inp": [ 151 | false, 152 | false 153 | ], 154 | "Outp": [ 155 | false, 156 | false 157 | ] 158 | } 159 | ], 160 | "IsEnabled": false 161 | } 162 | } 163 | -------------------------------------------------------------------------------- /cache/EncodingHex.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (InvalidByteError).Error() string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func Decode(dst []byte, src []byte) (int, error)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | true, 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | true, 28 | false, 29 | false, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": true 35 | }, 36 | "func DecodeString(s string) ([]byte, error)": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | true, 41 | false, 42 | false 43 | ], 44 | "Outp": [ 45 | false, 46 | true, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": true 52 | }, 53 | "func DecodedLen(x int) int": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | false 59 | ], 60 | "Outp": [ 61 | false, 62 | false 63 | ] 64 | } 65 | ], 66 | "IsEnabled": false 67 | }, 68 | "func Dump(data []byte) string": { 69 | "Blocks": [ 70 | { 71 | "Inp": [ 72 | true, 73 | false 74 | ], 75 | "Outp": [ 76 | false, 77 | true 78 | ] 79 | } 80 | ], 81 | "IsEnabled": false 82 | }, 83 | "func Dumper(w io.Writer) io.WriteCloser": { 84 | "Blocks": [ 85 | { 86 | "Inp": [ 87 | false, 88 | true 89 | ], 90 | "Outp": [ 91 | true, 92 | false 93 | ] 94 | } 95 | ], 96 | "IsEnabled": false 97 | }, 98 | "func Encode(dst []byte, src []byte) int": { 99 | "Blocks": [ 100 | { 101 | "Inp": [ 102 | false, 103 | true, 104 | false 105 | ], 106 | "Outp": [ 107 | true, 108 | false, 109 | false 110 | ] 111 | } 112 | ], 113 | "IsEnabled": false 114 | }, 115 | "func EncodeToString(src []byte) string": { 116 | "Blocks": [ 117 | { 118 | "Inp": [ 119 | true, 120 | false 121 | ], 122 | "Outp": [ 123 | false, 124 | true 125 | ] 126 | } 127 | ], 128 | "IsEnabled": false 129 | }, 130 | "func EncodedLen(n int) int": { 131 | "Blocks": [ 132 | { 133 | "Inp": [ 134 | false, 135 | false 136 | ], 137 | "Outp": [ 138 | false, 139 | false 140 | ] 141 | } 142 | ], 143 | "IsEnabled": false 144 | }, 145 | "func NewDecoder(r io.Reader) io.Reader": { 146 | "Blocks": [ 147 | { 148 | "Inp": [ 149 | true, 150 | false 151 | ], 152 | "Outp": [ 153 | false, 154 | true 155 | ] 156 | } 157 | ], 158 | "IsEnabled": true 159 | }, 160 | "func NewEncoder(w io.Writer) io.Writer": { 161 | "Blocks": [ 162 | { 163 | "Inp": [ 164 | false, 165 | true 166 | ], 167 | "Outp": [ 168 | true, 169 | false 170 | ] 171 | } 172 | ], 173 | "IsEnabled": false 174 | } 175 | } 176 | -------------------------------------------------------------------------------- /cache/EncodingPem.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func Decode(data []byte) (p *Block, rest []byte)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | true 14 | ] 15 | } 16 | ], 17 | "IsEnabled": true 18 | }, 19 | "func Encode(out io.Writer, b *Block) error": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | true, 25 | false 26 | ], 27 | "Outp": [ 28 | true, 29 | false, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": true 35 | }, 36 | "func EncodeToMemory(b *Block) []byte": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | true, 41 | false 42 | ], 43 | "Outp": [ 44 | false, 45 | true 46 | ] 47 | } 48 | ], 49 | "IsEnabled": true 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /cache/Errors.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func As(err error, target interface{}) bool": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": true 18 | }, 19 | "func Is(err error, target error) bool": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false, 25 | false 26 | ], 27 | "Outp": [ 28 | false, 29 | false, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": false 35 | }, 36 | "func New(text string) error": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | true, 41 | false 42 | ], 43 | "Outp": [ 44 | false, 45 | true 46 | ] 47 | } 48 | ], 49 | "IsEnabled": true 50 | }, 51 | "func Unwrap(err error) error": { 52 | "Blocks": [ 53 | { 54 | "Inp": [ 55 | true, 56 | false 57 | ], 58 | "Outp": [ 59 | false, 60 | true 61 | ] 62 | } 63 | ], 64 | "IsEnabled": true 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /cache/HashMaphash.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Hash).BlockSize() int": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*Hash).Reset()": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false 22 | ], 23 | "Outp": [ 24 | false 25 | ] 26 | } 27 | ], 28 | "IsEnabled": false 29 | }, 30 | "func (*Hash).Seed() Seed": { 31 | "Blocks": [ 32 | { 33 | "Inp": [ 34 | false, 35 | false 36 | ], 37 | "Outp": [ 38 | false, 39 | false 40 | ] 41 | } 42 | ], 43 | "IsEnabled": false 44 | }, 45 | "func (*Hash).SetSeed(seed Seed)": { 46 | "Blocks": [ 47 | { 48 | "Inp": [ 49 | false, 50 | false 51 | ], 52 | "Outp": [ 53 | false, 54 | false 55 | ] 56 | } 57 | ], 58 | "IsEnabled": false 59 | }, 60 | "func (*Hash).Size() int": { 61 | "Blocks": [ 62 | { 63 | "Inp": [ 64 | false, 65 | false 66 | ], 67 | "Outp": [ 68 | false, 69 | false 70 | ] 71 | } 72 | ], 73 | "IsEnabled": false 74 | }, 75 | "func (*Hash).Sum(b []byte) []byte": { 76 | "Blocks": [ 77 | { 78 | "Inp": [ 79 | false, 80 | false, 81 | false 82 | ], 83 | "Outp": [ 84 | false, 85 | false, 86 | false 87 | ] 88 | } 89 | ], 90 | "IsEnabled": false 91 | }, 92 | "func (*Hash).Sum64() uint64": { 93 | "Blocks": [ 94 | { 95 | "Inp": [ 96 | false, 97 | false 98 | ], 99 | "Outp": [ 100 | false, 101 | false 102 | ] 103 | } 104 | ], 105 | "IsEnabled": false 106 | }, 107 | "func (*Hash).Write(b []byte) (int, error)": { 108 | "Blocks": [ 109 | { 110 | "Inp": [ 111 | false, 112 | false, 113 | false, 114 | false 115 | ], 116 | "Outp": [ 117 | false, 118 | false, 119 | false, 120 | false 121 | ] 122 | } 123 | ], 124 | "IsEnabled": false 125 | }, 126 | "func (*Hash).WriteByte(b byte) error": { 127 | "Blocks": [ 128 | { 129 | "Inp": [ 130 | false, 131 | false, 132 | false 133 | ], 134 | "Outp": [ 135 | false, 136 | false, 137 | false 138 | ] 139 | } 140 | ], 141 | "IsEnabled": false 142 | }, 143 | "func (*Hash).WriteString(s string) (int, error)": { 144 | "Blocks": [ 145 | { 146 | "Inp": [ 147 | false, 148 | false, 149 | false, 150 | false 151 | ], 152 | "Outp": [ 153 | false, 154 | false, 155 | false, 156 | false 157 | ] 158 | } 159 | ], 160 | "IsEnabled": false 161 | }, 162 | "func MakeSeed() Seed": { 163 | "Blocks": [ 164 | { 165 | "Inp": [ 166 | false 167 | ], 168 | "Outp": [ 169 | false 170 | ] 171 | } 172 | ], 173 | "IsEnabled": false 174 | } 175 | } 176 | -------------------------------------------------------------------------------- /cache/Html.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func EscapeString(s string) string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | true 12 | ] 13 | } 14 | ], 15 | "IsEnabled": true 16 | }, 17 | "func UnescapeString(s string) string": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | true, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | true 27 | ] 28 | } 29 | ], 30 | "IsEnabled": true 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /cache/IoIoutil.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (Writer).Write(p []byte) (n int, err error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | true, 8 | false, 9 | false 10 | ], 11 | "Outp": [ 12 | true, 13 | false, 14 | false, 15 | false 16 | ] 17 | } 18 | ], 19 | "IsEnabled": false 20 | }, 21 | "func NopCloser(r io.Reader) io.ReadCloser": { 22 | "Blocks": [ 23 | { 24 | "Inp": [ 25 | true, 26 | false 27 | ], 28 | "Outp": [ 29 | false, 30 | true 31 | ] 32 | } 33 | ], 34 | "IsEnabled": true 35 | }, 36 | "func ReadAll(r io.Reader) ([]byte, error)": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | true, 41 | false, 42 | false 43 | ], 44 | "Outp": [ 45 | false, 46 | true, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": true 52 | }, 53 | "func ReadDir(dirname string) ([]os.FileInfo, error)": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | false, 59 | false 60 | ], 61 | "Outp": [ 62 | false, 63 | false, 64 | false 65 | ] 66 | } 67 | ], 68 | "IsEnabled": false 69 | }, 70 | "func ReadFile(filename string) ([]byte, error)": { 71 | "Blocks": [ 72 | { 73 | "Inp": [ 74 | false, 75 | false, 76 | false 77 | ], 78 | "Outp": [ 79 | false, 80 | false, 81 | false 82 | ] 83 | } 84 | ], 85 | "IsEnabled": false 86 | }, 87 | "func TempDir(dir string, pattern string) (name string, err error)": { 88 | "Blocks": [ 89 | { 90 | "Inp": [ 91 | false, 92 | false, 93 | false, 94 | false 95 | ], 96 | "Outp": [ 97 | false, 98 | false, 99 | false, 100 | false 101 | ] 102 | } 103 | ], 104 | "IsEnabled": false 105 | }, 106 | "func TempFile(dir string, pattern string) (f *os.File, err error)": { 107 | "Blocks": [ 108 | { 109 | "Inp": [ 110 | false, 111 | false, 112 | false, 113 | false 114 | ], 115 | "Outp": [ 116 | false, 117 | false, 118 | false, 119 | false 120 | ] 121 | } 122 | ], 123 | "IsEnabled": false 124 | }, 125 | "func WriteFile(filename string, data []byte, perm os.FileMode) error": { 126 | "Blocks": [ 127 | { 128 | "Inp": [ 129 | false, 130 | false, 131 | false, 132 | false 133 | ], 134 | "Outp": [ 135 | false, 136 | false, 137 | false, 138 | false 139 | ] 140 | } 141 | ], 142 | "IsEnabled": false 143 | } 144 | } 145 | -------------------------------------------------------------------------------- /cache/LogSyslog.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Writer).Alert(m string) error": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (*Writer).Close() error": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | }, 34 | "func (*Writer).Crit(m string) error": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | false, 39 | false, 40 | false 41 | ], 42 | "Outp": [ 43 | false, 44 | false, 45 | false 46 | ] 47 | } 48 | ], 49 | "IsEnabled": false 50 | }, 51 | "func (*Writer).Debug(m string) error": { 52 | "Blocks": [ 53 | { 54 | "Inp": [ 55 | false, 56 | false, 57 | false 58 | ], 59 | "Outp": [ 60 | false, 61 | false, 62 | false 63 | ] 64 | } 65 | ], 66 | "IsEnabled": false 67 | }, 68 | "func (*Writer).Emerg(m string) error": { 69 | "Blocks": [ 70 | { 71 | "Inp": [ 72 | false, 73 | false, 74 | false 75 | ], 76 | "Outp": [ 77 | false, 78 | false, 79 | false 80 | ] 81 | } 82 | ], 83 | "IsEnabled": false 84 | }, 85 | "func (*Writer).Err(m string) error": { 86 | "Blocks": [ 87 | { 88 | "Inp": [ 89 | false, 90 | false, 91 | false 92 | ], 93 | "Outp": [ 94 | false, 95 | false, 96 | false 97 | ] 98 | } 99 | ], 100 | "IsEnabled": false 101 | }, 102 | "func (*Writer).Info(m string) error": { 103 | "Blocks": [ 104 | { 105 | "Inp": [ 106 | false, 107 | false, 108 | false 109 | ], 110 | "Outp": [ 111 | false, 112 | false, 113 | false 114 | ] 115 | } 116 | ], 117 | "IsEnabled": false 118 | }, 119 | "func (*Writer).Notice(m string) error": { 120 | "Blocks": [ 121 | { 122 | "Inp": [ 123 | false, 124 | false, 125 | false 126 | ], 127 | "Outp": [ 128 | false, 129 | false, 130 | false 131 | ] 132 | } 133 | ], 134 | "IsEnabled": false 135 | }, 136 | "func (*Writer).Warning(m string) error": { 137 | "Blocks": [ 138 | { 139 | "Inp": [ 140 | false, 141 | false, 142 | false 143 | ], 144 | "Outp": [ 145 | false, 146 | false, 147 | false 148 | ] 149 | } 150 | ], 151 | "IsEnabled": false 152 | }, 153 | "func (*Writer).Write(b []byte) (int, error)": { 154 | "Blocks": [ 155 | { 156 | "Inp": [ 157 | false, 158 | false, 159 | false, 160 | false 161 | ], 162 | "Outp": [ 163 | false, 164 | false, 165 | false, 166 | false 167 | ] 168 | } 169 | ], 170 | "IsEnabled": false 171 | }, 172 | "func Dial(network string, raddr string, priority Priority, tag string) (*Writer, error)": { 173 | "Blocks": [ 174 | { 175 | "Inp": [ 176 | false, 177 | false, 178 | false, 179 | false, 180 | false, 181 | false 182 | ], 183 | "Outp": [ 184 | false, 185 | false, 186 | false, 187 | false, 188 | false, 189 | false 190 | ] 191 | } 192 | ], 193 | "IsEnabled": false 194 | }, 195 | "func New(priority Priority, tag string) (*Writer, error)": { 196 | "Blocks": [ 197 | { 198 | "Inp": [ 199 | false, 200 | false, 201 | false, 202 | false 203 | ], 204 | "Outp": [ 205 | false, 206 | false, 207 | false, 208 | false 209 | ] 210 | } 211 | ], 212 | "IsEnabled": false 213 | }, 214 | "func NewLogger(p Priority, logFlag int) (*log.Logger, error)": { 215 | "Blocks": [ 216 | { 217 | "Inp": [ 218 | false, 219 | false, 220 | false, 221 | false 222 | ], 223 | "Outp": [ 224 | false, 225 | false, 226 | false, 227 | false 228 | ] 229 | } 230 | ], 231 | "IsEnabled": false 232 | } 233 | } 234 | -------------------------------------------------------------------------------- /cache/Mime.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*WordDecoder).Decode(word string) (string, error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | true, 8 | false, 9 | false 10 | ], 11 | "Outp": [ 12 | false, 13 | false, 14 | true, 15 | false 16 | ] 17 | } 18 | ], 19 | "IsEnabled": true 20 | }, 21 | "func (*WordDecoder).DecodeHeader(header string) (string, error)": { 22 | "Blocks": [ 23 | { 24 | "Inp": [ 25 | false, 26 | true, 27 | false, 28 | false 29 | ], 30 | "Outp": [ 31 | false, 32 | false, 33 | true, 34 | false 35 | ] 36 | } 37 | ], 38 | "IsEnabled": true 39 | }, 40 | "func (WordEncoder).Encode(charset string, s string) string": { 41 | "Blocks": [ 42 | { 43 | "Inp": [ 44 | false, 45 | false, 46 | true, 47 | false 48 | ], 49 | "Outp": [ 50 | false, 51 | false, 52 | false, 53 | true 54 | ] 55 | } 56 | ], 57 | "IsEnabled": true 58 | }, 59 | "func AddExtensionType(ext string, typ string) error": { 60 | "Blocks": [ 61 | { 62 | "Inp": [ 63 | false, 64 | false, 65 | false 66 | ], 67 | "Outp": [ 68 | false, 69 | false, 70 | false 71 | ] 72 | } 73 | ], 74 | "IsEnabled": false 75 | }, 76 | "func ExtensionsByType(typ string) ([]string, error)": { 77 | "Blocks": [ 78 | { 79 | "Inp": [ 80 | false, 81 | false, 82 | false 83 | ], 84 | "Outp": [ 85 | false, 86 | false, 87 | false 88 | ] 89 | } 90 | ], 91 | "IsEnabled": false 92 | }, 93 | "func FormatMediaType(t string, param map[string]string) string": { 94 | "Blocks": [ 95 | { 96 | "Inp": [ 97 | true, 98 | true, 99 | false 100 | ], 101 | "Outp": [ 102 | false, 103 | false, 104 | true 105 | ] 106 | } 107 | ], 108 | "IsEnabled": true 109 | }, 110 | "func ParseMediaType(v string) (mediatype string, params map[string]string, err error)": { 111 | "Blocks": [ 112 | { 113 | "Inp": [ 114 | true, 115 | false, 116 | false, 117 | false 118 | ], 119 | "Outp": [ 120 | false, 121 | true, 122 | true, 123 | false 124 | ] 125 | } 126 | ], 127 | "IsEnabled": true 128 | }, 129 | "func TypeByExtension(ext string) string": { 130 | "Blocks": [ 131 | { 132 | "Inp": [ 133 | false, 134 | false 135 | ], 136 | "Outp": [ 137 | false, 138 | false 139 | ] 140 | } 141 | ], 142 | "IsEnabled": false 143 | } 144 | } 145 | -------------------------------------------------------------------------------- /cache/MimeMultipart.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*FileHeader).Open() (File, error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": true 18 | }, 19 | "func (*Form).RemoveAll() error": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | }, 34 | "func (*Part).Close() error": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | false, 39 | false 40 | ], 41 | "Outp": [ 42 | false, 43 | false 44 | ] 45 | } 46 | ], 47 | "IsEnabled": false 48 | }, 49 | "func (*Part).FileName() string": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | false, 54 | false 55 | ], 56 | "Outp": [ 57 | false, 58 | false 59 | ] 60 | } 61 | ], 62 | "IsEnabled": false 63 | }, 64 | "func (*Part).FormName() string": { 65 | "Blocks": [ 66 | { 67 | "Inp": [ 68 | false, 69 | false 70 | ], 71 | "Outp": [ 72 | false, 73 | false 74 | ] 75 | } 76 | ], 77 | "IsEnabled": false 78 | }, 79 | "func (*Part).Read(d []byte) (n int, err error)": { 80 | "Blocks": [ 81 | { 82 | "Inp": [ 83 | true, 84 | false, 85 | false, 86 | false 87 | ], 88 | "Outp": [ 89 | false, 90 | true, 91 | false, 92 | false 93 | ] 94 | } 95 | ], 96 | "IsEnabled": true 97 | }, 98 | "func (*Reader).NextPart() (*Part, error)": { 99 | "Blocks": [ 100 | { 101 | "Inp": [ 102 | true, 103 | false, 104 | false 105 | ], 106 | "Outp": [ 107 | false, 108 | true, 109 | false 110 | ] 111 | } 112 | ], 113 | "IsEnabled": true 114 | }, 115 | "func (*Reader).NextRawPart() (*Part, error)": { 116 | "Blocks": [ 117 | { 118 | "Inp": [ 119 | true, 120 | false, 121 | false 122 | ], 123 | "Outp": [ 124 | false, 125 | true, 126 | false 127 | ] 128 | } 129 | ], 130 | "IsEnabled": true 131 | }, 132 | "func (*Reader).ReadForm(maxMemory int64) (*Form, error)": { 133 | "Blocks": [ 134 | { 135 | "Inp": [ 136 | true, 137 | false, 138 | false, 139 | false 140 | ], 141 | "Outp": [ 142 | false, 143 | false, 144 | true, 145 | false 146 | ] 147 | } 148 | ], 149 | "IsEnabled": true 150 | }, 151 | "func (*Writer).Boundary() string": { 152 | "Blocks": [ 153 | { 154 | "Inp": [ 155 | false, 156 | false 157 | ], 158 | "Outp": [ 159 | false, 160 | false 161 | ] 162 | } 163 | ], 164 | "IsEnabled": false 165 | }, 166 | "func (*Writer).Close() error": { 167 | "Blocks": [ 168 | { 169 | "Inp": [ 170 | false, 171 | false 172 | ], 173 | "Outp": [ 174 | false, 175 | false 176 | ] 177 | } 178 | ], 179 | "IsEnabled": false 180 | }, 181 | "func (*Writer).CreateFormField(fieldname string) (io.Writer, error)": { 182 | "Blocks": [ 183 | { 184 | "Inp": [ 185 | false, 186 | false, 187 | true, 188 | false 189 | ], 190 | "Outp": [ 191 | true, 192 | false, 193 | false, 194 | false 195 | ] 196 | } 197 | ], 198 | "IsEnabled": true 199 | }, 200 | "func (*Writer).CreateFormFile(fieldname string, filename string) (io.Writer, error)": { 201 | "Blocks": [ 202 | { 203 | "Inp": [ 204 | false, 205 | false, 206 | false, 207 | true, 208 | false 209 | ], 210 | "Outp": [ 211 | true, 212 | false, 213 | false, 214 | false, 215 | false 216 | ] 217 | } 218 | ], 219 | "IsEnabled": true 220 | }, 221 | "func (*Writer).CreatePart(header net/textproto.MIMEHeader) (io.Writer, error)": { 222 | "Blocks": [ 223 | { 224 | "Inp": [ 225 | false, 226 | false, 227 | true, 228 | false 229 | ], 230 | "Outp": [ 231 | true, 232 | false, 233 | false, 234 | false 235 | ] 236 | } 237 | ], 238 | "IsEnabled": true 239 | }, 240 | "func (*Writer).FormDataContentType() string": { 241 | "Blocks": [ 242 | { 243 | "Inp": [ 244 | false, 245 | false 246 | ], 247 | "Outp": [ 248 | false, 249 | false 250 | ] 251 | } 252 | ], 253 | "IsEnabled": false 254 | }, 255 | "func (*Writer).SetBoundary(boundary string) error": { 256 | "Blocks": [ 257 | { 258 | "Inp": [ 259 | false, 260 | false, 261 | false 262 | ], 263 | "Outp": [ 264 | false, 265 | false, 266 | false 267 | ] 268 | } 269 | ], 270 | "IsEnabled": false 271 | }, 272 | "func (*Writer).WriteField(fieldname string, value string) error": { 273 | "Blocks": [ 274 | { 275 | "Inp": [ 276 | false, 277 | true, 278 | true, 279 | false 280 | ], 281 | "Outp": [ 282 | true, 283 | false, 284 | false, 285 | false 286 | ] 287 | } 288 | ], 289 | "IsEnabled": true 290 | }, 291 | "func NewReader(r io.Reader, boundary string) *Reader": { 292 | "Blocks": [ 293 | { 294 | "Inp": [ 295 | true, 296 | false, 297 | false 298 | ], 299 | "Outp": [ 300 | false, 301 | false, 302 | true 303 | ] 304 | } 305 | ], 306 | "IsEnabled": true 307 | }, 308 | "func NewWriter(w io.Writer) *Writer": { 309 | "Blocks": [ 310 | { 311 | "Inp": [ 312 | false, 313 | true 314 | ], 315 | "Outp": [ 316 | true, 317 | false 318 | ] 319 | } 320 | ], 321 | "IsEnabled": true 322 | } 323 | } 324 | -------------------------------------------------------------------------------- /cache/MimeQuotedprintable.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Reader).Read(p []byte) (n int, err error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false, 9 | false 10 | ], 11 | "Outp": [ 12 | false, 13 | true, 14 | false, 15 | false 16 | ] 17 | } 18 | ], 19 | "IsEnabled": true 20 | }, 21 | "func (*Writer).Close() error": { 22 | "Blocks": [ 23 | { 24 | "Inp": [ 25 | false, 26 | false 27 | ], 28 | "Outp": [ 29 | false, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": false 35 | }, 36 | "func (*Writer).Write(p []byte) (n int, err error)": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | false, 41 | true, 42 | false, 43 | false 44 | ], 45 | "Outp": [ 46 | true, 47 | false, 48 | false, 49 | false 50 | ] 51 | } 52 | ], 53 | "IsEnabled": true 54 | }, 55 | "func NewReader(r io.Reader) *Reader": { 56 | "Blocks": [ 57 | { 58 | "Inp": [ 59 | true, 60 | false 61 | ], 62 | "Outp": [ 63 | false, 64 | true 65 | ] 66 | } 67 | ], 68 | "IsEnabled": true 69 | }, 70 | "func NewWriter(w io.Writer) *Writer": { 71 | "Blocks": [ 72 | { 73 | "Inp": [ 74 | false, 75 | true 76 | ], 77 | "Outp": [ 78 | true, 79 | false 80 | ] 81 | } 82 | ], 83 | "IsEnabled": true 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /cache/NetHttpCgi.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Handler).ServeHTTP(rw net/http.ResponseWriter, req *net/http.Request)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func Request() (*net/http.Request, error)": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | }, 34 | "func RequestFromMap(params map[string]string) (*net/http.Request, error)": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | false, 39 | false, 40 | false 41 | ], 42 | "Outp": [ 43 | false, 44 | false, 45 | false 46 | ] 47 | } 48 | ], 49 | "IsEnabled": false 50 | }, 51 | "func Serve(handler net/http.Handler) error": { 52 | "Blocks": [ 53 | { 54 | "Inp": [ 55 | false, 56 | false 57 | ], 58 | "Outp": [ 59 | false, 60 | false 61 | ] 62 | } 63 | ], 64 | "IsEnabled": false 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /cache/NetHttpCookiejar.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Jar).Cookies(u *net/url.URL) (cookies []*net/http.Cookie)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (*Jar).SetCookies(u *net/url.URL, cookies []*net/http.Cookie)": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false, 25 | false 26 | ], 27 | "Outp": [ 28 | false, 29 | false, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": false 35 | }, 36 | "func (PublicSuffixList).PublicSuffix(domain string) string": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | false, 41 | false, 42 | false 43 | ], 44 | "Outp": [ 45 | false, 46 | false, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": false 52 | }, 53 | "func (PublicSuffixList).String() string": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | false 59 | ], 60 | "Outp": [ 61 | false, 62 | false 63 | ] 64 | } 65 | ], 66 | "IsEnabled": false 67 | }, 68 | "func New(o *Options) (*Jar, error)": { 69 | "Blocks": [ 70 | { 71 | "Inp": [ 72 | false, 73 | false, 74 | false 75 | ], 76 | "Outp": [ 77 | false, 78 | false, 79 | false 80 | ] 81 | } 82 | ], 83 | "IsEnabled": false 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /cache/NetHttpFcgi.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func ProcessEnv(r *net/http.Request) map[string]string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func Serve(l net.Listener, handler net/http.Handler) error": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | false, 23 | false 24 | ], 25 | "Outp": [ 26 | false, 27 | false, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /cache/NetMail.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Address).String() string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*AddressParser).Parse(address string) (*Address, error)": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | true, 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | false, 29 | true, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": true 35 | }, 36 | "func (*AddressParser).ParseList(list string) ([]*Address, error)": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | false, 41 | true, 42 | false, 43 | false 44 | ], 45 | "Outp": [ 46 | false, 47 | false, 48 | true, 49 | false 50 | ] 51 | } 52 | ], 53 | "IsEnabled": true 54 | }, 55 | "func (Header).AddressList(key string) ([]*Address, error)": { 56 | "Blocks": [ 57 | { 58 | "Inp": [ 59 | false, 60 | false, 61 | false, 62 | false 63 | ], 64 | "Outp": [ 65 | false, 66 | false, 67 | false, 68 | false 69 | ] 70 | } 71 | ], 72 | "IsEnabled": false 73 | }, 74 | "func (Header).Date() (time.Time, error)": { 75 | "Blocks": [ 76 | { 77 | "Inp": [ 78 | false, 79 | false, 80 | false 81 | ], 82 | "Outp": [ 83 | false, 84 | false, 85 | false 86 | ] 87 | } 88 | ], 89 | "IsEnabled": false 90 | }, 91 | "func (Header).Get(key string) string": { 92 | "Blocks": [ 93 | { 94 | "Inp": [ 95 | true, 96 | false, 97 | false 98 | ], 99 | "Outp": [ 100 | false, 101 | false, 102 | true 103 | ] 104 | } 105 | ], 106 | "IsEnabled": true 107 | }, 108 | "func ParseAddress(address string) (*Address, error)": { 109 | "Blocks": [ 110 | { 111 | "Inp": [ 112 | true, 113 | false, 114 | false 115 | ], 116 | "Outp": [ 117 | false, 118 | true, 119 | false 120 | ] 121 | } 122 | ], 123 | "IsEnabled": true 124 | }, 125 | "func ParseAddressList(list string) ([]*Address, error)": { 126 | "Blocks": [ 127 | { 128 | "Inp": [ 129 | true, 130 | false, 131 | false 132 | ], 133 | "Outp": [ 134 | false, 135 | true, 136 | false 137 | ] 138 | } 139 | ], 140 | "IsEnabled": true 141 | }, 142 | "func ParseDate(date string) (time.Time, error)": { 143 | "Blocks": [ 144 | { 145 | "Inp": [ 146 | false, 147 | false, 148 | false 149 | ], 150 | "Outp": [ 151 | false, 152 | false, 153 | false 154 | ] 155 | } 156 | ], 157 | "IsEnabled": false 158 | }, 159 | "func ReadMessage(r io.Reader) (msg *Message, err error)": { 160 | "Blocks": [ 161 | { 162 | "Inp": [ 163 | true, 164 | false, 165 | false 166 | ], 167 | "Outp": [ 168 | false, 169 | true, 170 | false 171 | ] 172 | } 173 | ], 174 | "IsEnabled": true 175 | } 176 | } 177 | -------------------------------------------------------------------------------- /cache/NetRpcJsonrpc.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func Dial(network string, address string) (*net/rpc.Client, error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false, 9 | false 10 | ], 11 | "Outp": [ 12 | false, 13 | false, 14 | false, 15 | false 16 | ] 17 | } 18 | ], 19 | "IsEnabled": false 20 | }, 21 | "func NewClient(conn io.ReadWriteCloser) *net/rpc.Client": { 22 | "Blocks": [ 23 | { 24 | "Inp": [ 25 | true, 26 | false 27 | ], 28 | "Outp": [ 29 | false, 30 | true 31 | ] 32 | } 33 | ], 34 | "IsEnabled": false 35 | }, 36 | "func NewClientCodec(conn io.ReadWriteCloser) net/rpc.ClientCodec": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | false, 41 | false 42 | ], 43 | "Outp": [ 44 | false, 45 | false 46 | ] 47 | } 48 | ], 49 | "IsEnabled": false 50 | }, 51 | "func NewServerCodec(conn io.ReadWriteCloser) net/rpc.ServerCodec": { 52 | "Blocks": [ 53 | { 54 | "Inp": [ 55 | false, 56 | false 57 | ], 58 | "Outp": [ 59 | false, 60 | false 61 | ] 62 | } 63 | ], 64 | "IsEnabled": false 65 | }, 66 | "func ServeConn(conn io.ReadWriteCloser)": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | false 71 | ], 72 | "Outp": [ 73 | false 74 | ] 75 | } 76 | ], 77 | "IsEnabled": false 78 | } 79 | } 80 | -------------------------------------------------------------------------------- /cache/OsUser.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*User).GroupIds() ([]string, error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (UnknownGroupError).Error() string": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | false 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | }, 34 | "func (UnknownGroupIdError).Error() string": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | false, 39 | false 40 | ], 41 | "Outp": [ 42 | false, 43 | false 44 | ] 45 | } 46 | ], 47 | "IsEnabled": false 48 | }, 49 | "func (UnknownUserError).Error() string": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | false, 54 | false 55 | ], 56 | "Outp": [ 57 | false, 58 | false 59 | ] 60 | } 61 | ], 62 | "IsEnabled": false 63 | }, 64 | "func (UnknownUserIdError).Error() string": { 65 | "Blocks": [ 66 | { 67 | "Inp": [ 68 | false, 69 | false 70 | ], 71 | "Outp": [ 72 | false, 73 | false 74 | ] 75 | } 76 | ], 77 | "IsEnabled": false 78 | }, 79 | "func Current() (*User, error)": { 80 | "Blocks": [ 81 | { 82 | "Inp": [ 83 | false, 84 | false 85 | ], 86 | "Outp": [ 87 | false, 88 | false 89 | ] 90 | } 91 | ], 92 | "IsEnabled": false 93 | }, 94 | "func Lookup(username string) (*User, error)": { 95 | "Blocks": [ 96 | { 97 | "Inp": [ 98 | false, 99 | false, 100 | false 101 | ], 102 | "Outp": [ 103 | false, 104 | false, 105 | false 106 | ] 107 | } 108 | ], 109 | "IsEnabled": false 110 | }, 111 | "func LookupGroup(name string) (*Group, error)": { 112 | "Blocks": [ 113 | { 114 | "Inp": [ 115 | false, 116 | false, 117 | false 118 | ], 119 | "Outp": [ 120 | false, 121 | false, 122 | false 123 | ] 124 | } 125 | ], 126 | "IsEnabled": false 127 | }, 128 | "func LookupGroupId(gid string) (*Group, error)": { 129 | "Blocks": [ 130 | { 131 | "Inp": [ 132 | false, 133 | false, 134 | false 135 | ], 136 | "Outp": [ 137 | false, 138 | false, 139 | false 140 | ] 141 | } 142 | ], 143 | "IsEnabled": false 144 | }, 145 | "func LookupId(uid string) (*User, error)": { 146 | "Blocks": [ 147 | { 148 | "Inp": [ 149 | false, 150 | false, 151 | false 152 | ], 153 | "Outp": [ 154 | false, 155 | false, 156 | false 157 | ] 158 | } 159 | ], 160 | "IsEnabled": false 161 | } 162 | } 163 | -------------------------------------------------------------------------------- /cache/Path.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func Base(path string) string": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | true 12 | ] 13 | } 14 | ], 15 | "IsEnabled": true 16 | }, 17 | "func Clean(path string) string": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | true, 22 | false 23 | ], 24 | "Outp": [ 25 | false, 26 | true 27 | ] 28 | } 29 | ], 30 | "IsEnabled": true 31 | }, 32 | "func Dir(path string) string": { 33 | "Blocks": [ 34 | { 35 | "Inp": [ 36 | true, 37 | false 38 | ], 39 | "Outp": [ 40 | false, 41 | true 42 | ] 43 | } 44 | ], 45 | "IsEnabled": true 46 | }, 47 | "func Ext(path string) string": { 48 | "Blocks": [ 49 | { 50 | "Inp": [ 51 | true, 52 | false 53 | ], 54 | "Outp": [ 55 | false, 56 | true 57 | ] 58 | } 59 | ], 60 | "IsEnabled": true 61 | }, 62 | "func IsAbs(path string) bool": { 63 | "Blocks": [ 64 | { 65 | "Inp": [ 66 | false, 67 | false 68 | ], 69 | "Outp": [ 70 | false, 71 | false 72 | ] 73 | } 74 | ], 75 | "IsEnabled": false 76 | }, 77 | "func Join(elem ...string) string": { 78 | "Blocks": [ 79 | { 80 | "Inp": [ 81 | true, 82 | false 83 | ], 84 | "Outp": [ 85 | false, 86 | true 87 | ] 88 | } 89 | ], 90 | "IsEnabled": true 91 | }, 92 | "func Match(pattern string, name string) (matched bool, err error)": { 93 | "Blocks": [ 94 | { 95 | "Inp": [ 96 | false, 97 | false, 98 | false, 99 | false 100 | ], 101 | "Outp": [ 102 | false, 103 | false, 104 | false, 105 | false 106 | ] 107 | } 108 | ], 109 | "IsEnabled": false 110 | }, 111 | "func Split(path string) (dir string, file string)": { 112 | "Blocks": [ 113 | { 114 | "Inp": [ 115 | true, 116 | false, 117 | false 118 | ], 119 | "Outp": [ 120 | false, 121 | true, 122 | true 123 | ] 124 | } 125 | ], 126 | "IsEnabled": true 127 | } 128 | } 129 | -------------------------------------------------------------------------------- /cache/PathFilepath.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func Abs(path string) (string, error)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": true 18 | }, 19 | "func Base(path string) string": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | true, 24 | false 25 | ], 26 | "Outp": [ 27 | false, 28 | true 29 | ] 30 | } 31 | ], 32 | "IsEnabled": true 33 | }, 34 | "func Clean(path string) string": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | true, 39 | false 40 | ], 41 | "Outp": [ 42 | false, 43 | true 44 | ] 45 | } 46 | ], 47 | "IsEnabled": true 48 | }, 49 | "func Dir(path string) string": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | true, 54 | false 55 | ], 56 | "Outp": [ 57 | false, 58 | true 59 | ] 60 | } 61 | ], 62 | "IsEnabled": true 63 | }, 64 | "func EvalSymlinks(path string) (string, error)": { 65 | "Blocks": [ 66 | { 67 | "Inp": [ 68 | true, 69 | false, 70 | false 71 | ], 72 | "Outp": [ 73 | false, 74 | true, 75 | false 76 | ] 77 | } 78 | ], 79 | "IsEnabled": true 80 | }, 81 | "func Ext(path string) string": { 82 | "Blocks": [ 83 | { 84 | "Inp": [ 85 | true, 86 | false 87 | ], 88 | "Outp": [ 89 | false, 90 | true 91 | ] 92 | } 93 | ], 94 | "IsEnabled": true 95 | }, 96 | "func FromSlash(path string) string": { 97 | "Blocks": [ 98 | { 99 | "Inp": [ 100 | true, 101 | false 102 | ], 103 | "Outp": [ 104 | false, 105 | true 106 | ] 107 | } 108 | ], 109 | "IsEnabled": true 110 | }, 111 | "func Glob(pattern string) (matches []string, err error)": { 112 | "Blocks": [ 113 | { 114 | "Inp": [ 115 | true, 116 | false, 117 | false 118 | ], 119 | "Outp": [ 120 | false, 121 | true, 122 | false 123 | ] 124 | } 125 | ], 126 | "IsEnabled": true 127 | }, 128 | "func HasPrefix(p string, prefix string) bool": { 129 | "Blocks": [ 130 | { 131 | "Inp": [ 132 | false, 133 | false, 134 | false 135 | ], 136 | "Outp": [ 137 | false, 138 | false, 139 | false 140 | ] 141 | } 142 | ], 143 | "IsEnabled": false 144 | }, 145 | "func IsAbs(path string) bool": { 146 | "Blocks": [ 147 | { 148 | "Inp": [ 149 | false, 150 | false 151 | ], 152 | "Outp": [ 153 | false, 154 | false 155 | ] 156 | } 157 | ], 158 | "IsEnabled": false 159 | }, 160 | "func Join(elem ...string) string": { 161 | "Blocks": [ 162 | { 163 | "Inp": [ 164 | true, 165 | false 166 | ], 167 | "Outp": [ 168 | false, 169 | true 170 | ] 171 | } 172 | ], 173 | "IsEnabled": true 174 | }, 175 | "func Match(pattern string, name string) (matched bool, err error)": { 176 | "Blocks": [ 177 | { 178 | "Inp": [ 179 | false, 180 | false, 181 | false, 182 | false 183 | ], 184 | "Outp": [ 185 | false, 186 | false, 187 | false, 188 | false 189 | ] 190 | } 191 | ], 192 | "IsEnabled": false 193 | }, 194 | "func Rel(basepath string, targpath string) (string, error)": { 195 | "Blocks": [ 196 | { 197 | "Inp": [ 198 | true, 199 | true, 200 | false, 201 | false 202 | ], 203 | "Outp": [ 204 | false, 205 | false, 206 | true, 207 | false 208 | ] 209 | } 210 | ], 211 | "IsEnabled": true 212 | }, 213 | "func Split(path string) (dir string, file string)": { 214 | "Blocks": [ 215 | { 216 | "Inp": [ 217 | true, 218 | false, 219 | false 220 | ], 221 | "Outp": [ 222 | false, 223 | true, 224 | true 225 | ] 226 | } 227 | ], 228 | "IsEnabled": true 229 | }, 230 | "func SplitList(path string) []string": { 231 | "Blocks": [ 232 | { 233 | "Inp": [ 234 | true, 235 | false 236 | ], 237 | "Outp": [ 238 | false, 239 | true 240 | ] 241 | } 242 | ], 243 | "IsEnabled": true 244 | }, 245 | "func ToSlash(path string) string": { 246 | "Blocks": [ 247 | { 248 | "Inp": [ 249 | true, 250 | false 251 | ], 252 | "Outp": [ 253 | false, 254 | true 255 | ] 256 | } 257 | ], 258 | "IsEnabled": true 259 | }, 260 | "func VolumeName(path string) string": { 261 | "Blocks": [ 262 | { 263 | "Inp": [ 264 | true, 265 | false 266 | ], 267 | "Outp": [ 268 | false, 269 | true 270 | ] 271 | } 272 | ], 273 | "IsEnabled": true 274 | }, 275 | "func Walk(root string, walkFn WalkFunc) error": { 276 | "Blocks": [ 277 | { 278 | "Inp": [ 279 | false, 280 | false, 281 | false 282 | ], 283 | "Outp": [ 284 | false, 285 | false, 286 | false 287 | ] 288 | } 289 | ], 290 | "IsEnabled": false 291 | } 292 | } 293 | -------------------------------------------------------------------------------- /cache/Sync.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Cond).Broadcast()": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false 7 | ], 8 | "Outp": [ 9 | false 10 | ] 11 | } 12 | ], 13 | "IsEnabled": false 14 | }, 15 | "func (*Cond).Signal()": { 16 | "Blocks": [ 17 | { 18 | "Inp": [ 19 | false 20 | ], 21 | "Outp": [ 22 | false 23 | ] 24 | } 25 | ], 26 | "IsEnabled": false 27 | }, 28 | "func (*Cond).Wait()": { 29 | "Blocks": [ 30 | { 31 | "Inp": [ 32 | false 33 | ], 34 | "Outp": [ 35 | false 36 | ] 37 | } 38 | ], 39 | "IsEnabled": false 40 | }, 41 | "func (*Map).Delete(key interface{})": { 42 | "Blocks": [ 43 | { 44 | "Inp": [ 45 | false, 46 | false 47 | ], 48 | "Outp": [ 49 | false, 50 | false 51 | ] 52 | } 53 | ], 54 | "IsEnabled": false 55 | }, 56 | "func (*Map).Load(key interface{}) (value interface{}, ok bool)": { 57 | "Blocks": [ 58 | { 59 | "Inp": [ 60 | true, 61 | false, 62 | false, 63 | false 64 | ], 65 | "Outp": [ 66 | false, 67 | false, 68 | true, 69 | false 70 | ] 71 | } 72 | ], 73 | "IsEnabled": true 74 | }, 75 | "func (*Map).LoadAndDelete(key interface{}) (value interface{}, loaded bool)": { 76 | "Blocks": [ 77 | { 78 | "Inp": [ 79 | false, 80 | false, 81 | false, 82 | false 83 | ], 84 | "Outp": [ 85 | false, 86 | false, 87 | false, 88 | false 89 | ] 90 | } 91 | ], 92 | "IsEnabled": false 93 | }, 94 | "func (*Map).LoadOrStore(key interface{}, value interface{}) (actual interface{}, loaded bool)": { 95 | "Blocks": [ 96 | { 97 | "Inp": [ 98 | true, 99 | false, 100 | false, 101 | false, 102 | false 103 | ], 104 | "Outp": [ 105 | false, 106 | false, 107 | false, 108 | true, 109 | false 110 | ] 111 | }, 112 | { 113 | "Inp": [ 114 | false, 115 | true, 116 | true, 117 | false, 118 | false 119 | ], 120 | "Outp": [ 121 | true, 122 | false, 123 | false, 124 | true, 125 | false 126 | ] 127 | } 128 | ], 129 | "IsEnabled": true 130 | }, 131 | "func (*Map).Range(f func(key interface{}, value interface{}) bool)": { 132 | "Blocks": [ 133 | { 134 | "Inp": [ 135 | true, 136 | false 137 | ], 138 | "Outp": [ 139 | false, 140 | true 141 | ] 142 | } 143 | ], 144 | "IsEnabled": false 145 | }, 146 | "func (*Map).Store(key interface{}, value interface{})": { 147 | "Blocks": [ 148 | { 149 | "Inp": [ 150 | false, 151 | true, 152 | true 153 | ], 154 | "Outp": [ 155 | true, 156 | false, 157 | false 158 | ] 159 | } 160 | ], 161 | "IsEnabled": true 162 | }, 163 | "func (*Mutex).Lock()": { 164 | "Blocks": [ 165 | { 166 | "Inp": [ 167 | false 168 | ], 169 | "Outp": [ 170 | false 171 | ] 172 | } 173 | ], 174 | "IsEnabled": false 175 | }, 176 | "func (*Mutex).Unlock()": { 177 | "Blocks": [ 178 | { 179 | "Inp": [ 180 | false 181 | ], 182 | "Outp": [ 183 | false 184 | ] 185 | } 186 | ], 187 | "IsEnabled": false 188 | }, 189 | "func (*Once).Do(f func())": { 190 | "Blocks": [ 191 | { 192 | "Inp": [ 193 | false, 194 | false 195 | ], 196 | "Outp": [ 197 | false, 198 | false 199 | ] 200 | } 201 | ], 202 | "IsEnabled": false 203 | }, 204 | "func (*Pool).Get() interface{}": { 205 | "Blocks": [ 206 | { 207 | "Inp": [ 208 | true, 209 | false 210 | ], 211 | "Outp": [ 212 | false, 213 | true 214 | ] 215 | } 216 | ], 217 | "IsEnabled": true 218 | }, 219 | "func (*Pool).Put(x interface{})": { 220 | "Blocks": [ 221 | { 222 | "Inp": [ 223 | false, 224 | true 225 | ], 226 | "Outp": [ 227 | true, 228 | false 229 | ] 230 | } 231 | ], 232 | "IsEnabled": true 233 | }, 234 | "func (*RWMutex).Lock()": { 235 | "Blocks": [ 236 | { 237 | "Inp": [ 238 | false 239 | ], 240 | "Outp": [ 241 | false 242 | ] 243 | } 244 | ], 245 | "IsEnabled": false 246 | }, 247 | "func (*RWMutex).RLock()": { 248 | "Blocks": [ 249 | { 250 | "Inp": [ 251 | false 252 | ], 253 | "Outp": [ 254 | false 255 | ] 256 | } 257 | ], 258 | "IsEnabled": false 259 | }, 260 | "func (*RWMutex).RLocker() Locker": { 261 | "Blocks": [ 262 | { 263 | "Inp": [ 264 | false, 265 | false 266 | ], 267 | "Outp": [ 268 | false, 269 | false 270 | ] 271 | } 272 | ], 273 | "IsEnabled": false 274 | }, 275 | "func (*RWMutex).RUnlock()": { 276 | "Blocks": [ 277 | { 278 | "Inp": [ 279 | false 280 | ], 281 | "Outp": [ 282 | false 283 | ] 284 | } 285 | ], 286 | "IsEnabled": false 287 | }, 288 | "func (*RWMutex).Unlock()": { 289 | "Blocks": [ 290 | { 291 | "Inp": [ 292 | false 293 | ], 294 | "Outp": [ 295 | false 296 | ] 297 | } 298 | ], 299 | "IsEnabled": false 300 | }, 301 | "func (*WaitGroup).Add(delta int)": { 302 | "Blocks": [ 303 | { 304 | "Inp": [ 305 | false, 306 | false 307 | ], 308 | "Outp": [ 309 | false, 310 | false 311 | ] 312 | } 313 | ], 314 | "IsEnabled": false 315 | }, 316 | "func (*WaitGroup).Done()": { 317 | "Blocks": [ 318 | { 319 | "Inp": [ 320 | false 321 | ], 322 | "Outp": [ 323 | false 324 | ] 325 | } 326 | ], 327 | "IsEnabled": false 328 | }, 329 | "func (*WaitGroup).Wait()": { 330 | "Blocks": [ 331 | { 332 | "Inp": [ 333 | false 334 | ], 335 | "Outp": [ 336 | false 337 | ] 338 | } 339 | ], 340 | "IsEnabled": false 341 | }, 342 | "func (Locker).Lock()": { 343 | "Blocks": [ 344 | { 345 | "Inp": [ 346 | false 347 | ], 348 | "Outp": [ 349 | false 350 | ] 351 | } 352 | ], 353 | "IsEnabled": false 354 | }, 355 | "func (Locker).Unlock()": { 356 | "Blocks": [ 357 | { 358 | "Inp": [ 359 | false 360 | ], 361 | "Outp": [ 362 | false 363 | ] 364 | } 365 | ], 366 | "IsEnabled": false 367 | }, 368 | "func NewCond(l Locker) *Cond": { 369 | "Blocks": [ 370 | { 371 | "Inp": [ 372 | false, 373 | false 374 | ], 375 | "Outp": [ 376 | false, 377 | false 378 | ] 379 | } 380 | ], 381 | "IsEnabled": false 382 | } 383 | } 384 | -------------------------------------------------------------------------------- /cache/TextScanner.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Position).IsValid() bool": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*Scanner).Init(src io.Reader) *Scanner": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | false, 22 | true, 23 | false 24 | ], 25 | "Outp": [ 26 | true, 27 | false, 28 | true 29 | ] 30 | } 31 | ], 32 | "IsEnabled": true 33 | }, 34 | "func (*Scanner).Next() rune": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | true, 39 | false 40 | ], 41 | "Outp": [ 42 | false, 43 | true 44 | ] 45 | } 46 | ], 47 | "IsEnabled": false 48 | }, 49 | "func (*Scanner).Peek() rune": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | true, 54 | false 55 | ], 56 | "Outp": [ 57 | false, 58 | true 59 | ] 60 | } 61 | ], 62 | "IsEnabled": false 63 | }, 64 | "func (*Scanner).Pos() (pos Position)": { 65 | "Blocks": [ 66 | { 67 | "Inp": [ 68 | false, 69 | false 70 | ], 71 | "Outp": [ 72 | false, 73 | false 74 | ] 75 | } 76 | ], 77 | "IsEnabled": false 78 | }, 79 | "func (*Scanner).Scan() rune": { 80 | "Blocks": [ 81 | { 82 | "Inp": [ 83 | true, 84 | false 85 | ], 86 | "Outp": [ 87 | false, 88 | true 89 | ] 90 | } 91 | ], 92 | "IsEnabled": false 93 | }, 94 | "func (*Scanner).TokenText() string": { 95 | "Blocks": [ 96 | { 97 | "Inp": [ 98 | true, 99 | false 100 | ], 101 | "Outp": [ 102 | false, 103 | true 104 | ] 105 | } 106 | ], 107 | "IsEnabled": true 108 | }, 109 | "func (Position).String() string": { 110 | "Blocks": [ 111 | { 112 | "Inp": [ 113 | false, 114 | false 115 | ], 116 | "Outp": [ 117 | false, 118 | false 119 | ] 120 | } 121 | ], 122 | "IsEnabled": false 123 | }, 124 | "func TokenString(tok rune) string": { 125 | "Blocks": [ 126 | { 127 | "Inp": [ 128 | true, 129 | false 130 | ], 131 | "Outp": [ 132 | false, 133 | true 134 | ] 135 | } 136 | ], 137 | "IsEnabled": false 138 | } 139 | } 140 | -------------------------------------------------------------------------------- /cache/TextTabwriter.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (*Writer).Flush() error": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | false 12 | ] 13 | } 14 | ], 15 | "IsEnabled": false 16 | }, 17 | "func (*Writer).Init(output io.Writer, minwidth int, tabwidth int, padding int, padchar byte, flags uint) *Writer": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | true, 22 | false, 23 | false, 24 | false, 25 | false, 26 | false, 27 | false, 28 | true 29 | ], 30 | "Outp": [ 31 | false, 32 | true, 33 | false, 34 | false, 35 | false, 36 | false, 37 | false, 38 | false 39 | ] 40 | } 41 | ], 42 | "IsEnabled": true 43 | }, 44 | "func (*Writer).Write(buf []byte) (n int, err error)": { 45 | "Blocks": [ 46 | { 47 | "Inp": [ 48 | false, 49 | true, 50 | false, 51 | false 52 | ], 53 | "Outp": [ 54 | true, 55 | false, 56 | false, 57 | false 58 | ] 59 | } 60 | ], 61 | "IsEnabled": true 62 | }, 63 | "func NewWriter(output io.Writer, minwidth int, tabwidth int, padding int, padchar byte, flags uint) *Writer": { 64 | "Blocks": [ 65 | { 66 | "Inp": [ 67 | false, 68 | false, 69 | false, 70 | false, 71 | false, 72 | false, 73 | true 74 | ], 75 | "Outp": [ 76 | true, 77 | false, 78 | false, 79 | false, 80 | false, 81 | false, 82 | false 83 | ] 84 | } 85 | ], 86 | "IsEnabled": true 87 | } 88 | } 89 | -------------------------------------------------------------------------------- /cache/Unicode.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func (SpecialCase).ToLower(r rune) rune": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | false, 7 | true, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | false, 13 | true 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func (SpecialCase).ToTitle(r rune) rune": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | false, 24 | true, 25 | false 26 | ], 27 | "Outp": [ 28 | false, 29 | false, 30 | true 31 | ] 32 | } 33 | ], 34 | "IsEnabled": false 35 | }, 36 | "func (SpecialCase).ToUpper(r rune) rune": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | false, 41 | true, 42 | false 43 | ], 44 | "Outp": [ 45 | false, 46 | false, 47 | true 48 | ] 49 | } 50 | ], 51 | "IsEnabled": false 52 | }, 53 | "func In(r rune, ranges ...*RangeTable) bool": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | false, 58 | false, 59 | false 60 | ], 61 | "Outp": [ 62 | false, 63 | false, 64 | false 65 | ] 66 | } 67 | ], 68 | "IsEnabled": false 69 | }, 70 | "func Is(rangeTab *RangeTable, r rune) bool": { 71 | "Blocks": [ 72 | { 73 | "Inp": [ 74 | false, 75 | false, 76 | false 77 | ], 78 | "Outp": [ 79 | false, 80 | false, 81 | false 82 | ] 83 | } 84 | ], 85 | "IsEnabled": false 86 | }, 87 | "func IsControl(r rune) bool": { 88 | "Blocks": [ 89 | { 90 | "Inp": [ 91 | false, 92 | false 93 | ], 94 | "Outp": [ 95 | false, 96 | false 97 | ] 98 | } 99 | ], 100 | "IsEnabled": false 101 | }, 102 | "func IsDigit(r rune) bool": { 103 | "Blocks": [ 104 | { 105 | "Inp": [ 106 | false, 107 | false 108 | ], 109 | "Outp": [ 110 | false, 111 | false 112 | ] 113 | } 114 | ], 115 | "IsEnabled": false 116 | }, 117 | "func IsGraphic(r rune) bool": { 118 | "Blocks": [ 119 | { 120 | "Inp": [ 121 | false, 122 | false 123 | ], 124 | "Outp": [ 125 | false, 126 | false 127 | ] 128 | } 129 | ], 130 | "IsEnabled": false 131 | }, 132 | "func IsLetter(r rune) bool": { 133 | "Blocks": [ 134 | { 135 | "Inp": [ 136 | false, 137 | false 138 | ], 139 | "Outp": [ 140 | false, 141 | false 142 | ] 143 | } 144 | ], 145 | "IsEnabled": false 146 | }, 147 | "func IsLower(r rune) bool": { 148 | "Blocks": [ 149 | { 150 | "Inp": [ 151 | false, 152 | false 153 | ], 154 | "Outp": [ 155 | false, 156 | false 157 | ] 158 | } 159 | ], 160 | "IsEnabled": false 161 | }, 162 | "func IsMark(r rune) bool": { 163 | "Blocks": [ 164 | { 165 | "Inp": [ 166 | false, 167 | false 168 | ], 169 | "Outp": [ 170 | false, 171 | false 172 | ] 173 | } 174 | ], 175 | "IsEnabled": false 176 | }, 177 | "func IsNumber(r rune) bool": { 178 | "Blocks": [ 179 | { 180 | "Inp": [ 181 | false, 182 | false 183 | ], 184 | "Outp": [ 185 | false, 186 | false 187 | ] 188 | } 189 | ], 190 | "IsEnabled": false 191 | }, 192 | "func IsOneOf(ranges []*RangeTable, r rune) bool": { 193 | "Blocks": [ 194 | { 195 | "Inp": [ 196 | false, 197 | false, 198 | false 199 | ], 200 | "Outp": [ 201 | false, 202 | false, 203 | false 204 | ] 205 | } 206 | ], 207 | "IsEnabled": false 208 | }, 209 | "func IsPrint(r rune) bool": { 210 | "Blocks": [ 211 | { 212 | "Inp": [ 213 | false, 214 | false 215 | ], 216 | "Outp": [ 217 | false, 218 | false 219 | ] 220 | } 221 | ], 222 | "IsEnabled": false 223 | }, 224 | "func IsPunct(r rune) bool": { 225 | "Blocks": [ 226 | { 227 | "Inp": [ 228 | false, 229 | false 230 | ], 231 | "Outp": [ 232 | false, 233 | false 234 | ] 235 | } 236 | ], 237 | "IsEnabled": false 238 | }, 239 | "func IsSpace(r rune) bool": { 240 | "Blocks": [ 241 | { 242 | "Inp": [ 243 | false, 244 | false 245 | ], 246 | "Outp": [ 247 | false, 248 | false 249 | ] 250 | } 251 | ], 252 | "IsEnabled": false 253 | }, 254 | "func IsSymbol(r rune) bool": { 255 | "Blocks": [ 256 | { 257 | "Inp": [ 258 | false, 259 | false 260 | ], 261 | "Outp": [ 262 | false, 263 | false 264 | ] 265 | } 266 | ], 267 | "IsEnabled": false 268 | }, 269 | "func IsTitle(r rune) bool": { 270 | "Blocks": [ 271 | { 272 | "Inp": [ 273 | false, 274 | false 275 | ], 276 | "Outp": [ 277 | false, 278 | false 279 | ] 280 | } 281 | ], 282 | "IsEnabled": false 283 | }, 284 | "func IsUpper(r rune) bool": { 285 | "Blocks": [ 286 | { 287 | "Inp": [ 288 | false, 289 | false 290 | ], 291 | "Outp": [ 292 | false, 293 | false 294 | ] 295 | } 296 | ], 297 | "IsEnabled": false 298 | }, 299 | "func SimpleFold(r rune) rune": { 300 | "Blocks": [ 301 | { 302 | "Inp": [ 303 | true, 304 | false 305 | ], 306 | "Outp": [ 307 | false, 308 | true 309 | ] 310 | } 311 | ], 312 | "IsEnabled": false 313 | }, 314 | "func To(_case int, r rune) rune": { 315 | "Blocks": [ 316 | { 317 | "Inp": [ 318 | false, 319 | true, 320 | false 321 | ], 322 | "Outp": [ 323 | false, 324 | false, 325 | true 326 | ] 327 | } 328 | ], 329 | "IsEnabled": false 330 | }, 331 | "func ToLower(r rune) rune": { 332 | "Blocks": [ 333 | { 334 | "Inp": [ 335 | true, 336 | false 337 | ], 338 | "Outp": [ 339 | false, 340 | true 341 | ] 342 | } 343 | ], 344 | "IsEnabled": false 345 | }, 346 | "func ToTitle(r rune) rune": { 347 | "Blocks": [ 348 | { 349 | "Inp": [ 350 | true, 351 | false 352 | ], 353 | "Outp": [ 354 | false, 355 | true 356 | ] 357 | } 358 | ], 359 | "IsEnabled": false 360 | }, 361 | "func ToUpper(r rune) rune": { 362 | "Blocks": [ 363 | { 364 | "Inp": [ 365 | true, 366 | false 367 | ], 368 | "Outp": [ 369 | false, 370 | true 371 | ] 372 | } 373 | ], 374 | "IsEnabled": false 375 | } 376 | } 377 | -------------------------------------------------------------------------------- /cache/UnicodeUtf16.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func Decode(s []uint16) []rune": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false 8 | ], 9 | "Outp": [ 10 | false, 11 | true 12 | ] 13 | } 14 | ], 15 | "IsEnabled": true 16 | }, 17 | "func DecodeRune(r1 rune, r2 rune) rune": { 18 | "Blocks": [ 19 | { 20 | "Inp": [ 21 | true, 22 | true, 23 | false 24 | ], 25 | "Outp": [ 26 | false, 27 | false, 28 | true 29 | ] 30 | } 31 | ], 32 | "IsEnabled": false 33 | }, 34 | "func Encode(s []rune) []uint16": { 35 | "Blocks": [ 36 | { 37 | "Inp": [ 38 | true, 39 | false 40 | ], 41 | "Outp": [ 42 | false, 43 | true 44 | ] 45 | } 46 | ], 47 | "IsEnabled": true 48 | }, 49 | "func EncodeRune(r rune) (r1 rune, r2 rune)": { 50 | "Blocks": [ 51 | { 52 | "Inp": [ 53 | true, 54 | false, 55 | false 56 | ], 57 | "Outp": [ 58 | false, 59 | true, 60 | true 61 | ] 62 | } 63 | ], 64 | "IsEnabled": true 65 | }, 66 | "func IsSurrogate(r rune) bool": { 67 | "Blocks": [ 68 | { 69 | "Inp": [ 70 | false, 71 | false 72 | ], 73 | "Outp": [ 74 | false, 75 | false 76 | ] 77 | } 78 | ], 79 | "IsEnabled": false 80 | } 81 | } 82 | -------------------------------------------------------------------------------- /cache/UnicodeUtf8.v2.json: -------------------------------------------------------------------------------- 1 | { 2 | "func DecodeLastRune(p []byte) (r rune, size int)": { 3 | "Blocks": [ 4 | { 5 | "Inp": [ 6 | true, 7 | false, 8 | false 9 | ], 10 | "Outp": [ 11 | false, 12 | true, 13 | false 14 | ] 15 | } 16 | ], 17 | "IsEnabled": false 18 | }, 19 | "func DecodeLastRuneInString(s string) (r rune, size int)": { 20 | "Blocks": [ 21 | { 22 | "Inp": [ 23 | true, 24 | false, 25 | false 26 | ], 27 | "Outp": [ 28 | false, 29 | true, 30 | false 31 | ] 32 | } 33 | ], 34 | "IsEnabled": false 35 | }, 36 | "func DecodeRune(p []byte) (r rune, size int)": { 37 | "Blocks": [ 38 | { 39 | "Inp": [ 40 | true, 41 | false, 42 | false 43 | ], 44 | "Outp": [ 45 | false, 46 | true, 47 | false 48 | ] 49 | } 50 | ], 51 | "IsEnabled": false 52 | }, 53 | "func DecodeRuneInString(s string) (r rune, size int)": { 54 | "Blocks": [ 55 | { 56 | "Inp": [ 57 | true, 58 | false, 59 | false 60 | ], 61 | "Outp": [ 62 | false, 63 | true, 64 | false 65 | ] 66 | } 67 | ], 68 | "IsEnabled": false 69 | }, 70 | "func EncodeRune(p []byte, r rune) int": { 71 | "Blocks": [ 72 | { 73 | "Inp": [ 74 | false, 75 | true, 76 | false 77 | ], 78 | "Outp": [ 79 | true, 80 | false, 81 | false 82 | ] 83 | } 84 | ], 85 | "IsEnabled": true 86 | }, 87 | "func FullRune(p []byte) bool": { 88 | "Blocks": [ 89 | { 90 | "Inp": [ 91 | false, 92 | false 93 | ], 94 | "Outp": [ 95 | false, 96 | false 97 | ] 98 | } 99 | ], 100 | "IsEnabled": false 101 | }, 102 | "func FullRuneInString(s string) bool": { 103 | "Blocks": [ 104 | { 105 | "Inp": [ 106 | false, 107 | false 108 | ], 109 | "Outp": [ 110 | false, 111 | false 112 | ] 113 | } 114 | ], 115 | "IsEnabled": false 116 | }, 117 | "func RuneCount(p []byte) int": { 118 | "Blocks": [ 119 | { 120 | "Inp": [ 121 | false, 122 | false 123 | ], 124 | "Outp": [ 125 | false, 126 | false 127 | ] 128 | } 129 | ], 130 | "IsEnabled": false 131 | }, 132 | "func RuneCountInString(s string) (n int)": { 133 | "Blocks": [ 134 | { 135 | "Inp": [ 136 | false, 137 | false 138 | ], 139 | "Outp": [ 140 | false, 141 | false 142 | ] 143 | } 144 | ], 145 | "IsEnabled": false 146 | }, 147 | "func RuneLen(r rune) int": { 148 | "Blocks": [ 149 | { 150 | "Inp": [ 151 | false, 152 | false 153 | ], 154 | "Outp": [ 155 | false, 156 | false 157 | ] 158 | } 159 | ], 160 | "IsEnabled": false 161 | }, 162 | "func RuneStart(b byte) bool": { 163 | "Blocks": [ 164 | { 165 | "Inp": [ 166 | false, 167 | false 168 | ], 169 | "Outp": [ 170 | false, 171 | false 172 | ] 173 | } 174 | ], 175 | "IsEnabled": false 176 | }, 177 | "func Valid(p []byte) bool": { 178 | "Blocks": [ 179 | { 180 | "Inp": [ 181 | false, 182 | false 183 | ], 184 | "Outp": [ 185 | false, 186 | false 187 | ] 188 | } 189 | ], 190 | "IsEnabled": false 191 | }, 192 | "func ValidRune(r rune) bool": { 193 | "Blocks": [ 194 | { 195 | "Inp": [ 196 | false, 197 | false 198 | ], 199 | "Outp": [ 200 | false, 201 | false 202 | ] 203 | } 204 | ], 205 | "IsEnabled": false 206 | }, 207 | "func ValidString(s string) bool": { 208 | "Blocks": [ 209 | { 210 | "Inp": [ 211 | false, 212 | false 213 | ], 214 | "Outp": [ 215 | false, 216 | false 217 | ] 218 | } 219 | ], 220 | "IsEnabled": false 221 | } 222 | } 223 | -------------------------------------------------------------------------------- /count-imports.sh: -------------------------------------------------------------------------------- 1 | cd $GOPATH/src && for dir in $(find -type d ! -path "*/vendor/*" ! -path "*/.git/*" | sort -u); do 2 | (cd $dir && go list -f '{{if .Standard}}{{.ImportPath}}{{end}}' -e) 3 | done | sort | uniq -c | sort -nr 4 | 5 | -------------------------------------------------------------------------------- /deprecated/demo-package/generated/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "io" 5 | "strconv" 6 | 7 | somepackage "github.com/gagliardetto/codebox/deprecated/demo-package" 8 | ) 9 | 10 | func main() {} 11 | func sink(v interface{}) {} 12 | 13 | func TaintStepTest_SomeFunc(sourceCQL interface{}) { 14 | { 15 | // The flow is from `in0` into `s`. 16 | 17 | // Assume that `sourceCQL` has the underlying type of `in0`: 18 | in0 := sourceCQL.(string) 19 | 20 | // Declare `s` variable: 21 | var s strconv.NumError 22 | 23 | // Call medium method that transfers the taint 24 | // from the parameter `in0` to parameter `s`; 25 | // `s` is now tainted. 26 | somepackage.SomeFunc(in0, nil, s, nil, somepackage.SomeStruct{}) 27 | 28 | // Sink the tainted `s`: 29 | sink(s) 30 | } 31 | } 32 | func TaintStepTest_SomeFuncA(sourceCQL interface{}) { 33 | { 34 | // The flow is from `in0` into `st`. 35 | 36 | // Assume that `sourceCQL` has the underlying type of `in0`: 37 | in0 := sourceCQL.(string) 38 | 39 | // Declare `st` variable: 40 | var st somepackage.SomeStruct 41 | 42 | // Call medium method that transfers the taint 43 | // from the parameter `in0` to parameter `st`; 44 | // `st` is now tainted. 45 | somepackage.SomeFunc(in0, nil, strconv.NumError{}, nil, st) 46 | 47 | // Sink the tainted `st`: 48 | sink(st) 49 | } 50 | } 51 | 52 | func TaintStepTest_Copy(source interface{}) { 53 | { 54 | // The flow is from `src` into `dst` 55 | // Assert type of `from`: 56 | src := source.(io.Reader) 57 | 58 | // Declare `into` variable: 59 | var dst io.Writer 60 | 61 | // Call medium method that transfers the taint 62 | // from the parameter `from` to another parameter 63 | // (`into` is now tainted). 64 | io.Copy(dst, src) 65 | 66 | // Sink the tainted `into`: 67 | sink(dst) 68 | } 69 | } 70 | func TaintStepTest_SomeFunc1B(sourceCQL interface{}) { 71 | { 72 | // The flow is from `pings` into `pongs`. 73 | 74 | // Assume that `sourceCQL` has the underlying type of `pings`: 75 | pings := sourceCQL.(<-chan string) 76 | 77 | // Declare `pongs` variable: 78 | var pongs chan<- string 79 | 80 | // Call medium method that transfers the taint 81 | // from the parameter `pings` to parameter `pongs`; 82 | // `pongs` is now tainted. 83 | somepackage.SomeFunc1b(pings, pongs) 84 | 85 | // Sink the tainted `pongs`: 86 | sink(pongs) 87 | } 88 | } 89 | -------------------------------------------------------------------------------- /deprecated/demo-package/pkg.go: -------------------------------------------------------------------------------- 1 | package somepackage 2 | 3 | import ( 4 | "io" 5 | "strconv" 6 | 7 | "github.com/gogo/protobuf/jsonpb" 8 | ) 9 | 10 | // Doc of SomeFunc 11 | func SomeFunc(in0 string, w io.Writer, s strconv.NumError, gh jsonpb.AnyResolver, st SomeStruct) (out0 string) { 12 | return "" 13 | } 14 | func SomeFunc1a(in0 chan bool, in1 chan *int, in2 *SomeStruct, in3 chan jsonpb.AnyResolver) (out0 string) { 15 | return "" 16 | } 17 | func SomeFunc1b(pings <-chan string, pongs chan<- string) (out0 string) { 18 | return "" 19 | } 20 | func SomeFunc1c(pings <-chan *SomeStruct, pongs chan<- *SomeStruct) (out0 string) { 21 | return "" 22 | } 23 | func SomeFunc1d(pings <-chan jsonpb.AnyResolver, pongs chan<- jsonpb.AnyResolver) (out0 string) { 24 | return "" 25 | } 26 | func SomeFunc2a(in0 int, in1 int8, in2 int16, in3 int32, in4 int64) (out0 string) { 27 | return "" 28 | } 29 | func SomeFunc2b(in0 *int, in1 *int8, in2 *int16, in3 *int32, in4 *int64) (out0 string) { 30 | return "" 31 | } 32 | func SomeFunc3(in0 uint, in1 uint8, in2 uint16, in3 uint32, in4 uint64) (out0 string) { 33 | return "" 34 | } 35 | func SomeFunc4(in0 *uint, in1 *uint8, in2 *uint16, in3 *uint32, in4 *uint64) (out0 string) { 36 | return "" 37 | } 38 | func SomeFunc5(in0 uintptr, in1 *uintptr) (out0 string) { 39 | return "" 40 | } 41 | func SomeFunc6(in0 float32, in1 float64, in2 *float32, in3 *float64) (out0 string) { 42 | return "" 43 | } 44 | func SomeFunc7(in0 rune, in1 *rune, in2 string, in3 *string) (out0 string) { 45 | return "" 46 | } 47 | func SomeFunc8(in0 complex64, in1 complex128, in2 *complex64, in3 *complex128) (out0 string) { 48 | return "" 49 | } 50 | func SomeFunc9a(in0 []SomeStruct, in1 []*SomeStruct) (out0 string) { 51 | return "" 52 | } 53 | func SomeFunc9b(in0 []SomeInterface, in1 []*SomeInterface) (out0 string) { 54 | return "" 55 | } 56 | 57 | //TODO (anonymous struct) 58 | func SomeFunc10(in0 struct{}) (out0 string) { 59 | return "" 60 | } 61 | 62 | type FuncAlias func(string) string 63 | 64 | func SomeFunc11(in0 func(bool) int, in1 FuncAlias) (out0 string) { 65 | return "" 66 | } 67 | 68 | //TODO (map of qualified) 69 | func SomeFunc12(in0 map[string]string, in1 map[string]FuncAlias) (out0 string) { 70 | return "" 71 | } 72 | func SomeFunc13(in0 interface{}, in1 []interface{}) (out0 string) { 73 | return "" 74 | } 75 | 76 | func unexportedFunc() (out0 string) { 77 | return "" 78 | } 79 | 80 | // This is interface doc. 81 | type SomeInterface interface { 82 | // a method documentation 83 | AMethod0(in string) bool 84 | // other comments 85 | // a lot of other comments 86 | AMethod1(in string) bool 87 | } 88 | 89 | // Doc of SomeStruct 90 | type SomeStruct struct { 91 | } 92 | 93 | // doc on pointer method 94 | func (st *SomeStruct) SomePtrMethod(methodInput0 string, r io.Reader) string { 95 | return "" 96 | } 97 | 98 | // doc on val method 99 | func (st SomeStruct) SomeValMethod(methodInput0 string, r io.Reader) string { 100 | return "" 101 | } 102 | 103 | type SomeType int 104 | 105 | // Pointer method on TypeMethod 106 | func (st *SomeType) TypePtrMethod(b bool) string { 107 | return "" 108 | } 109 | 110 | // Value method on TypeMethod with pointer param 111 | func (st SomeType) TypeValueMethod(b *bool) string { 112 | return "" 113 | } 114 | 115 | // variadic function 116 | func Options(opts ...string) (string, string) { 117 | return "", "" 118 | } 119 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/gagliardetto/codebox 2 | 3 | go 1.14 4 | 5 | require ( 6 | github.com/dave/jennifer v1.4.0 7 | github.com/gagliardetto/feparser v0.0.0-20201209222932-d64b39a45dd0 8 | github.com/gagliardetto/golang-go v0.0.0-20201020153340-53909ea70814 9 | github.com/gagliardetto/utilz v0.0.0-20200824151221-3a6131a12868 10 | github.com/gin-gonic/gin v1.7.0 11 | github.com/gogo/protobuf v1.3.1 12 | github.com/pkg/errors v0.9.1 13 | github.com/stretchr/testify v1.6.1 14 | golang.org/x/mod v0.3.0 15 | golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d 16 | gopkg.in/src-d/go-parse-utils.v1 v1.1.2 17 | gopkg.in/src-d/proteus.v1 v1.3.3 18 | ) 19 | -------------------------------------------------------------------------------- /queries/NegativeTestTaintFlow.ql: -------------------------------------------------------------------------------- 1 | /** 2 | * @kind problem 3 | */ 4 | 5 | import go 6 | 7 | /* A special helper function used inside the test code */ 8 | class Link extends TaintTracking::FunctionModel { 9 | Link() { hasQualifiedName(_, "link") } 10 | 11 | override predicate hasTaintFlow(FunctionInput inp, FunctionOutput outp) { 12 | inp.isParameter(0) and outp.isParameter(1) 13 | } 14 | } 15 | 16 | predicate isSource(DataFlow::Node source, DataFlow::CallNode call) { 17 | exists(Function fn | fn.hasQualifiedName(_, "newSource") | 18 | call = fn.getACall() and source = call.getResult() 19 | ) 20 | } 21 | 22 | predicate isSink(DataFlow::Node sink, DataFlow::CallNode call) { 23 | exists(Function fn | fn.hasQualifiedName(_, "sink") | 24 | call = fn.getACall() and sink = call.getArgument(1) 25 | ) 26 | } 27 | 28 | class FlowConf extends TaintTracking::Configuration { 29 | FlowConf() { this = "FlowConf" } 30 | 31 | override predicate isSource(DataFlow::Node source) { isSource(source, _) } 32 | 33 | override predicate isSink(DataFlow::Node sink) { isSink(sink, _) } 34 | } 35 | 36 | /** 37 | * True if the result of the provided sourceCall flows to the corresponding sink, 38 | * both marked by the same numeric first argument. 39 | */ 40 | predicate flowsToSink(DataFlow::CallNode sourceCall) { 41 | exists( 42 | FlowConf cfg, DataFlow::PathNode source, DataFlow::PathNode sink, DataFlow::CallNode sinkCall 43 | | 44 | cfg.hasFlowPath(source, sink) and 45 | ( 46 | isSource(source.getNode(), sourceCall) and 47 | isSink(sink.getNode(), sinkCall) and 48 | sourceCall.getArgument(0).getIntValue() = sinkCall.getArgument(0).getIntValue() 49 | ) 50 | ) 51 | } 52 | 53 | /* Show only flow sources that DON'T flow to their dedicated sink. */ 54 | from DataFlow::CallNode sourceCall 55 | where isSource(_, sourceCall) and not flowsToSink(sourceCall) 56 | select sourceCall, "No flow to its sink" 57 | -------------------------------------------------------------------------------- /queries/PositiveTestTaintFlow.ql: -------------------------------------------------------------------------------- 1 | /** 2 | * @kind path-problem 3 | */ 4 | 5 | import go 6 | import DataFlow::PathGraph 7 | 8 | class Source extends DataFlow::ExprNode { 9 | Source() { 10 | exists(Function fn | fn.hasQualifiedName(_, "newSource") | this = fn.getACall().getResult()) 11 | } 12 | } 13 | 14 | class Sink extends DataFlow::ExprNode { 15 | Sink() { 16 | exists(Function fn | fn.hasQualifiedName(_, "sink") | this = fn.getACall().getArgument(1)) 17 | } 18 | } 19 | 20 | class Link extends TaintTracking::FunctionModel { 21 | Link() { hasQualifiedName(_, "link") } 22 | 23 | override predicate hasTaintFlow(FunctionInput inp, FunctionOutput outp) { 24 | inp.isParameter(0) and outp.isParameter(1) 25 | } 26 | } 27 | 28 | class FlowConf extends TaintTracking::Configuration { 29 | FlowConf() { this = "FlowConf" } 30 | 31 | override predicate isSource(DataFlow::Node source) { source instanceof Source } 32 | 33 | override predicate isSink(DataFlow::Node sink) { sink instanceof Sink } 34 | } 35 | 36 | /* Show all successful flows of a source to its dedicated sink. */ 37 | from FlowConf cfg, DataFlow::PathNode source, DataFlow::PathNode sink 38 | where cfg.hasFlowPath(source, sink) 39 | select sink.getNode(), source, sink, "Flow from $@.", source.getNode(), "source" 40 | -------------------------------------------------------------------------------- /scanner/LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 source{d} 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /scanner/context.go: -------------------------------------------------------------------------------- 1 | package scanner 2 | 3 | import ( 4 | "fmt" 5 | "go/ast" 6 | "go/token" 7 | 8 | . "github.com/gagliardetto/utilz" 9 | ) 10 | 11 | // context holds all the scanning context of a single package. Contains all 12 | // the enum values we find during the scan as well as some info extracted 13 | // from the AST that will be needed throughout the process of scanning. 14 | type context struct { 15 | // types holds the type declarations indexed by the type name. The TypeSpec 16 | // is guaranteed to include the comments, if any, even though they were on 17 | // the GenDecl. 18 | types map[string]*ast.TypeSpec 19 | // consts holds the const objects indexed by the const name. We store an 20 | // object instead of a ValueSpec because the iota of the const is not 21 | // available there. 22 | consts map[string]*ast.Object 23 | // funcs holds the func objects indexed by the function or method name. 24 | // In case of methods, it's indexed by their qualified name, that is, 25 | // "TypeName.FuncName". 26 | funcs map[string]*ast.FuncDecl 27 | // enumValues contains all the values found until a point in time. 28 | // It is indexed by qualified type name e.g: time.Time 29 | enumValues map[string][]string 30 | // enums with string method 31 | enumWithString []string 32 | } 33 | 34 | func newContext(astFiles []*ast.File) (*context, error) { 35 | types, funcs := findPkgTypesAndFuncs(astFiles) 36 | return &context{ 37 | types: types, 38 | funcs: funcs, 39 | consts: findObjectsOfType(astFiles, ast.Con), 40 | enumValues: make(map[string][]string), 41 | enumWithString: []string{}, 42 | }, nil 43 | } 44 | 45 | func findPkgTypesAndFuncs(astFiles []*ast.File) (map[string]*ast.TypeSpec, map[string]*ast.FuncDecl) { 46 | var types = make(map[string]*ast.TypeSpec) 47 | var funcs = make(map[string]*ast.FuncDecl) 48 | 49 | for _, f := range astFiles { 50 | for _, d := range f.Decls { 51 | switch decl := d.(type) { 52 | case *ast.GenDecl: 53 | if decl.Tok == token.TYPE { 54 | for _, s := range decl.Specs { 55 | spec := s.(*ast.TypeSpec) 56 | if spec.Doc == nil { 57 | spec.Doc = decl.Doc 58 | } 59 | types[spec.Name.Name] = spec 60 | } 61 | } 62 | case *ast.FuncDecl: 63 | funcs[findName(decl)] = decl 64 | } 65 | } 66 | } 67 | 68 | return types, funcs 69 | } 70 | 71 | func findName(decl *ast.FuncDecl) (name string) { 72 | name = decl.Name.Name 73 | if decl.Recv == nil || len(decl.Recv.List) < 1 { 74 | return 75 | } 76 | 77 | var qualifier string 78 | switch t := decl.Recv.List[0].Type.(type) { 79 | case *ast.StarExpr: 80 | if ident, ok := t.X.(*ast.Ident); ok { 81 | qualifier = ident.Name 82 | } 83 | case *ast.Ident: 84 | qualifier = t.Name 85 | } 86 | 87 | if qualifier != "" { 88 | return fmt.Sprintf("%s.%s", qualifier, name) 89 | } 90 | return 91 | } 92 | 93 | func findObjectsOfType(astFiles []*ast.File, kind ast.ObjKind) map[string]*ast.Object { 94 | var objects = make(map[string]*ast.Object) 95 | 96 | for _, f := range astFiles { 97 | for k, o := range f.Scope.Objects { 98 | if o.Kind == kind { 99 | objects[k] = o 100 | } 101 | } 102 | } 103 | 104 | return objects 105 | } 106 | 107 | func (ctx *context) trySetDocs(name string, obj Documentable) { 108 | if typ, ok := ctx.types[name]; ok && typ.Doc != nil { 109 | obj.SetDocs(typ.Doc) 110 | obj.SetComments(typ.Comment) 111 | } else if fn, ok := ctx.funcs[name]; ok && fn.Doc != nil { 112 | obj.SetDocs(fn.Doc) 113 | } else if v, ok := ctx.consts[name]; ok { 114 | if spec, ok := v.Decl.(*ast.ValueSpec); ok { 115 | obj.SetDocs(spec.Doc) 116 | obj.SetComments(spec.Comment) 117 | } 118 | } 119 | } 120 | func (ctx *context) trySetDocsForInterfaceMethod(it string, method string, obj Documentable) { 121 | if itx0, ok := ctx.types[it]; ok { 122 | itx1, ok := itx0.Type.(*ast.InterfaceType) 123 | if ok { 124 | for _, mtx0 := range itx1.Methods.List { 125 | if mtx0.Names != nil && len(mtx0.Names) > 0 { 126 | if method == mtx0.Names[0].Name { 127 | obj.SetDocs(mtx0.Doc) 128 | obj.SetComments(mtx0.Comment) 129 | } 130 | } 131 | } 132 | } 133 | } 134 | } 135 | func (ctx *context) trySetDocsForStructField(st string, field string, obj Documentable) { 136 | found := false 137 | if stx0, ok := ctx.types[st]; ok { 138 | itx1, ok := stx0.Type.(*ast.StructType) 139 | if ok { 140 | for _, fldx0 := range itx1.Fields.List { 141 | if fldx0.Names != nil && len(fldx0.Names) > 0 { 142 | if field == fldx0.Names[0].Name { 143 | obj.SetDocs(fldx0.Doc) 144 | obj.SetComments(fldx0.Comment) 145 | found = true 146 | } 147 | } 148 | } 149 | } 150 | } 151 | 152 | if !found { 153 | // This trick is used for getting the comments/docs 154 | // which are set on an embedded type: 155 | if stx0, ok := ctx.types[st]; ok { 156 | itx1, ok := stx0.Type.(*ast.StructType) 157 | if ok { 158 | for index, fldx0 := range itx1.Fields.List { 159 | if Itoa(index) == field { 160 | obj.SetDocs(fldx0.Doc) 161 | obj.SetComments(fldx0.Comment) 162 | } 163 | } 164 | } 165 | } 166 | } 167 | } 168 | -------------------------------------------------------------------------------- /scanner/context_test.go: -------------------------------------------------------------------------------- 1 | package scanner 2 | 3 | import ( 4 | "os" 5 | "path/filepath" 6 | "testing" 7 | 8 | "github.com/stretchr/testify/assert" 9 | ) 10 | 11 | var goSrc = filepath.Join(os.Getenv("GOPATH"), "src") 12 | var projectDir = filepath.Join(goSrc, "gopkg.in/src-d/proteus.v1") 13 | 14 | func TestNewContext_error(t *testing.T) { 15 | createDirWithMultipleFiles("erroring") 16 | defer removeDir("erroring") 17 | _, err := newContext("gopkg.in/src-d/proteus.v1/fixtures/erroring/multiple") 18 | assert.NotNil(t, err) 19 | } 20 | 21 | func createDirWithMultipleFiles(pkg string) error { 22 | path := filepath.Join(projectDir, pkg) 23 | os.Mkdir(path, os.ModeDir) 24 | 25 | f, err := os.Create(filepath.Join(path, "foo.go")) 26 | if err != nil { 27 | return err 28 | } 29 | f.Write([]byte("package foo")) 30 | f.Close() 31 | 32 | f, err = os.Create(filepath.Join(path, "bar.go")) 33 | if err != nil { 34 | return err 35 | } 36 | f.Write([]byte("package bar")) 37 | f.Close() 38 | 39 | return nil 40 | } 41 | 42 | func removeDir(pkg string) { 43 | os.RemoveAll(filepath.Join(projectDir, pkg)) 44 | } 45 | -------------------------------------------------------------------------------- /scanner/package_test.go: -------------------------------------------------------------------------------- 1 | package scanner 2 | 3 | import ( 4 | "testing" 5 | 6 | "github.com/stretchr/testify/assert" 7 | ) 8 | 9 | func TestBaseType(t *testing.T) { 10 | typ := newBaseType() 11 | name := "BaseType" 12 | 13 | assertRepeatable(t, typ, name) 14 | assertNullable(t, typ, name) 15 | assert.Panics(t, func() { typ.TypeString() }, "does not implement TypeString") 16 | assert.Panics(t, func() { typ.String() }, "does not implement String") 17 | assert.Panics(t, func() { typ.UnqualifiedName() }, "does not implement UnqualifiedName") 18 | } 19 | 20 | func TestBasic(t *testing.T) { 21 | typ := NewBasic("basic") 22 | name := "Basic" 23 | 24 | assertRepeatable(t, typ, name) 25 | 26 | assert.True(t, typ.IsNullable(), "Basic is nullable by default") 27 | typ.SetNullable(false) 28 | assert.True(t, typ.IsNullable(), "Basic cannot be set not nullable") 29 | 30 | assert.Equal(t, "basic", typ.String(), "Basic.String returns type's name") 31 | assert.Equal(t, "basic", typ.TypeString(), "Basic.TypeString returns type's name") 32 | assert.Equal(t, "basic", typ.UnqualifiedName(), "Basic.UnqualifiedName returns type's name") 33 | } 34 | 35 | func TestNamed_withPath(t *testing.T) { 36 | typ := NewNamed("pkg", "name") 37 | name := "Named (with path)" 38 | 39 | assertRepeatable(t, typ, name) 40 | assertNullable(t, typ, name) 41 | 42 | assert.Equal(t, "pkg.name", typ.String(), "Named.String() (with path) returns type's name with path") 43 | assert.Equal(t, "pkg.name", typ.TypeString(), "Named.TypeString() (with path) returns type's name with path") 44 | assert.Equal(t, "name", typ.UnqualifiedName(), "Named.UnqualifiedName() (with path) returns type's name without path") 45 | } 46 | 47 | func TestNamed_withoutPath(t *testing.T) { 48 | typ := NewNamed("", "name") 49 | name := "Named (without path)" 50 | 51 | assertRepeatable(t, typ, name) 52 | assertNullable(t, typ, name) 53 | 54 | assert.Equal(t, "name", typ.String(), "Named.String() (with path) returns type's name without path") 55 | assert.Equal(t, "name", typ.TypeString(), "Named.TypeString() (with path) returns type's name without path") 56 | assert.Equal(t, "name", typ.UnqualifiedName(), "Named.UnqualifiedName() (with path) returns type's name without path") 57 | } 58 | 59 | func TestAlias_IsNullable(t *testing.T) { 60 | typ := NewAlias(newBaseType(), newBaseType()).(*Alias) 61 | 62 | assert.False(t, typ.IsNullable(), "Alias is not nullable if neither the type nor the underlying is nullable") 63 | typ.Type.SetNullable(true) 64 | typ.Underlying.SetNullable(false) 65 | assert.True(t, typ.IsNullable(), "Alias is nullable if the type is nullable but the underlying is not") 66 | typ.Type.SetNullable(false) 67 | typ.Underlying.SetNullable(true) 68 | assert.True(t, typ.IsNullable(), "Alias is nullable if the type is not nullable but the underlying is") 69 | typ.Type.SetNullable(true) 70 | typ.Underlying.SetNullable(true) 71 | assert.True(t, typ.IsNullable(), "Alias is nullable if both the type and the underlying are") 72 | } 73 | 74 | func TestAlias_IsRepeated(t *testing.T) { 75 | typ := NewAlias(newBaseType(), newBaseType()).(*Alias) 76 | 77 | assert.False(t, typ.IsRepeated(), "Alias is not repeated if neither the type nor the underlying is repeated") 78 | 79 | typ.Type.SetRepeated(true) 80 | typ.Underlying.SetRepeated(false) 81 | assert.True(t, typ.IsRepeated(), "Alias is repeated if the type is repeated but the underlying is not") 82 | typ.Type.SetRepeated(false) 83 | typ.Underlying.SetRepeated(true) 84 | assert.True(t, typ.IsRepeated(), "Alias is repeated if the type is not repeated but the underlying is") 85 | typ.Type.SetRepeated(true) 86 | typ.Underlying.SetRepeated(true) 87 | assert.True(t, typ.IsRepeated(), "Alias is repeated if both the type and the underlying are") 88 | } 89 | 90 | func TestAlias_stringMethods(t *testing.T) { 91 | typ := NewAlias(NewNamed("", "Aliasing"), NewBasic("string")) 92 | 93 | assert.Equal(t, "type Aliasing string", typ.String(), "Alias.String returns a type declaration for the alias") 94 | assert.Equal(t, "Aliasing", typ.TypeString(), "Alias.TypeString returns the type string for the alias") 95 | assert.Equal(t, "Aliasing", typ.UnqualifiedName(), "Alias.UnqualifiedName returns the unqualified name of the alias") 96 | } 97 | 98 | func TestMap(t *testing.T) { 99 | typ := NewMap(NewBasic("string"), NewBasic("int")) 100 | name := "Map" 101 | 102 | assertRepeatable(t, typ, name) 103 | assertNullable(t, typ, name) 104 | assert.Equal(t, "map[string]int", typ.String(), "Map.String returns a map signature") 105 | assert.Equal(t, "map[string]int", typ.TypeString(), "Map.TypeString returns a map signature") 106 | assert.Equal(t, "map[string]int", typ.UnqualifiedName(), "Map.UnqualifiedName returns a map signature") 107 | } 108 | 109 | // assertRepeatable asserts a type respond as expected to IsRepeated and SetRepeated. 110 | func assertRepeatable(t *testing.T, typ Type, name string) { 111 | assert.False(t, typ.IsRepeated(), "%s is not repeated by default", name) 112 | typ.SetRepeated(true) 113 | assert.True(t, typ.IsRepeated(), "%s can be set as repeated", name) 114 | typ.SetRepeated(false) 115 | assert.False(t, typ.IsRepeated(), "%s can be set as not repeated", name) 116 | } 117 | 118 | // assertNullable asserts a type responds as expected to IsNullable and SetNullable. 119 | func assertNullable(t *testing.T, typ Type, name string) { 120 | assert.False(t, typ.IsNullable(), "%s is not nullable by default", name) 121 | typ.SetNullable(true) 122 | assert.True(t, typ.IsNullable(), "%s can be set as nullable", name) 123 | typ.SetNullable(false) 124 | assert.False(t, typ.IsNullable(), "%s can be set as not nullable", name) 125 | } 126 | -------------------------------------------------------------------------------- /templates/taint-tracking_function.txt: -------------------------------------------------------------------------------- 1 | private class {{ .ClassName }} extends TaintTracking::FunctionModel { 2 | // signature: {{.Signature}} 3 | {{ .ClassName }}() { hasQualifiedName("{{ .PkgPath }}", "{{ .Name }}") } 4 | 5 | override predicate hasTaintFlow(FunctionInput inp, FunctionOutput outp) { 6 | {{ .CodeQL.GeneratedConditions }} 7 | } 8 | } -------------------------------------------------------------------------------- /templates/taint-tracking_interface-method.txt: -------------------------------------------------------------------------------- 1 | private class {{ .ClassName }} extends TaintTracking::FunctionModel, Method { 2 | // signature: {{.Func.Signature}} 3 | {{ .ClassName }}() { 4 | this.implements("{{ .Receiver.PkgPath }}", "{{ .Receiver.TypeName }}", "{{ .Func.Name }}") 5 | } 6 | 7 | override predicate hasTaintFlow(FunctionInput inp, FunctionOutput outp) { 8 | {{ .CodeQL.GeneratedConditions }} 9 | } 10 | } -------------------------------------------------------------------------------- /templates/taint-tracking_type-method.txt: -------------------------------------------------------------------------------- 1 | private class {{ .ClassName }} extends TaintTracking::FunctionModel, Method { 2 | // signature: {{.Func.Signature}} 3 | {{ .ClassName }}() { this.(Method).hasQualifiedName("{{ .Receiver.PkgPath }}", "{{ .Receiver.TypeName }}", "{{ .Func.Name }}") } 4 | 5 | override predicate hasTaintFlow(FunctionInput inp, FunctionOutput outp) { 6 | {{ .CodeQL.GeneratedConditions }} 7 | } 8 | } -------------------------------------------------------------------------------- /templates/v2-compressed-taint-tracking.txt: -------------------------------------------------------------------------------- 1 | private class {{ .ClassName }} extends {{ .Extends }} { 2 | FunctionInput inp; 3 | FunctionOutput outp; 4 | 5 | {{ .ClassName }}() { 6 | {{ .Conditions }} 7 | } 8 | 9 | override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { 10 | input = inp and output = outp 11 | } 12 | } 13 | --------------------------------------------------------------------------------