// license that can be found in the LICENSE file.

package resolution

func f /* =@fdecl */(n /* =@narg */ ast.Node) bool {
		if n /* =@ninit */, ok /* =@ok */ := n /* @narg */ .(*ast.SelectorExpr); ok /* @ok */ {
			sel = n /* @ninit */
	}
}

type c /* =@cdecl */ map[token.Pos]resolvedObj

func (v /* =@vdecl */ c /* @cdecl */) Visit(node /* =@nodearg */ ast.Node) (w /* =@w */ ast.Visitor) {}

const (

	JE	docall

	// Copy args to the stack.
	MOVL	CX, AX
	SALL	$2, AX
	SUBL	AX, SP			// room for args
	MOVL	SP, DI
	MOVL	libcall_args(BX), SI
	CLD
	REP; MOVSL

docall:
	// Call stdcall or cdecl function.
	// DI SI BP BX are preserved, SP is not
	CALL	libcall_fn(BX)
	MOVL	BP, SP

	// Return result.
	MOVL	fn+0(FP), BX
	MOVL	AX, libcall_r1(BX)
	MOVL	DX, libcall_r2(BX)

	// GetLastError().

			},
		},
		"doublePointerChecked": []ShortPosition{
			ShortPosition{
				Line:   42,
				Column: 91,
			},
		},
	}
	for _, decl := range f.Decls {
		if fdecl, ok := decl.(*ast.FuncDecl); ok {
			ast.Walk(&Visitor{expectation, fset, t}, fdecl.Body)
		}
	}
	for ident, positions := range expectation {
		for _, position := range positions {
			if !position.Visited {

		Name       *Name
		TParamList []*Field // nil means no type parameters
		Type       *FuncType
		Body       *BlockStmt // nil means no body (forward declaration)
		decl
	}
)

type decl struct{ node }

func (*decl) aDecl() {}

// All declarations belonging to the same group point to the same Group node.
type Group struct {
	_ int // not empty so we are guaranteed different Group instances
}

Alan Donovan <******@****.***> 1360693069 -0500

	}

	fileNode = file
	fileSize = int64(len(src))

	for _, decl := range file.Decls {
		// The first global variable, which is pretty short:
		//
		//	var unresolved = new(ast.Object)
		if decl, ok := decl.(*ast.GenDecl); ok && decl.Tok == token.VAR {
			declNode = decl
			declSize = int64(fset.Position(decl.End()).Offset - fset.Position(decl.Pos()).Offset)
			break
		}

	}
}

CONSTANTS
{{range .}}	{{synopsis .Doc}}
	{{node .Decl $.FSet}}

{{end}}{{end}}{{/*

*/}}{{with .Vars}}
VARIABLES
{{range .}}	{{synopsis .Doc}}
	{{node .Decl $.FSet}}

{{end}}{{end}}{{/*

*/}}{{with .Funcs}}
FUNCTIONS
{{range .}}	{{synopsis .Doc}}
	{{node .Decl $.FSet}}

{{end}}{{end}}{{/*

*/}}{{with .Types}}
TYPES
{{range .}}	{{synopsis .Doc}}
	{{node .Decl $.FSet}}

	for _, decl := range f.Decls {
		switch decl := decl.(type) {
		case *ast.FuncDecl:
			if decl.Recv != nil {
				log.Fatal("methods unsupported")
			}
			if decl.Body != nil {
				log.Fatal("unexpected function body")
			}
			fmt.Fprintf(w, "{%q, funcTag, %d},\n", decl.Name.Name, interner.intern(decl.Type))
		case *ast.GenDecl:
			if decl.Tok == token.IMPORT {

	fmt.Fprintf(w, "var builtins = [...]struct{ name string; abi int }{\n")
	for _, decl := range f.Decls {
		switch decl := decl.(type) {
		case *ast.FuncDecl:
			if decl.Recv != nil {
				log.Fatal("methods unsupported")
			}
			if decl.Body != nil {
				log.Fatal("unexpected function body")
			}
			declName := pkg + "." + decl.Name.Name
			decls[declName] = true

	}
	_, err = conf.Check("types", fset, []*ast.File{file}, info)
	if err != nil {
		log.Fatalf("Check failed: %s", err)
	}
	for _, decl := range file.Decls {
		decl, ok := decl.(*ast.GenDecl)
		if !ok || decl.Tok != token.CONST {
			continue
		}
		for _, spec := range decl.Specs {
			spec, ok := spec.(*ast.ValueSpec)
			if !ok || len(spec.Names) == 0 {
				continue
			}
			obj := info.ObjectOf(spec.Names[0])