How to use importsOfFile method of main Package

...120		p.auxInterfaces[pkg][ni.name.Name] = ni.it121	}122}123func (p *fileParser) parseFile(file *ast.File) (*model.Package, error) {124	allImports := importsOfFile(file)125	// Don't stomp imports provided by -imports. Those should take precedence.126	for pkg, path := range allImports {127		if _, ok := p.imports[pkg]; !ok {128			p.imports[pkg] = path129		}130	}131	// Add imports from auxiliary files, which might be needed for embedded interfaces.132	// Don't stomp any other imports.133	for _, f := range p.auxFiles {134		for pkg, path := range importsOfFile(f) {135			if _, ok := p.imports[pkg]; !ok {136				p.imports[pkg] = path137			}138		}139	}140	var is []*model.Interface141	for ni := range iterInterfaces(file) {142		i, err := p.parseInterface(ni.name.String(), "", ni.it)143		if err != nil {144			return nil, err145		}146		is = append(is, i)147	}148	return &model.Package{149		Name:       file.Name.String(),150		Interfaces: is,151	}, nil152}153func (p *fileParser) parsePackage(path string) error {154	var pkgs map[string]*ast.Package155	if imp, err := build.Import(path, p.srcDir, build.FindOnly); err != nil {156		return err157	} else if pkgs, err = parser.ParseDir(p.fileSet, imp.Dir, nil, 0); err != nil {158		return err159	}160	for _, pkg := range pkgs {161		file := ast.MergePackageFiles(pkg, ast.FilterFuncDuplicates|ast.FilterUnassociatedComments|ast.FilterImportDuplicates)162		if _, ok := p.importedInterfaces[path]; !ok {163			p.importedInterfaces[path] = make(map[string]*ast.InterfaceType)164		}165		for ni := range iterInterfaces(file) {166			p.importedInterfaces[path][ni.name.Name] = ni.it167		}168		for pkgName, pkgPath := range importsOfFile(file) {169			if _, ok := p.imports[pkgName]; !ok {170				p.imports[pkgName] = pkgPath171			}172		}173	}174	return nil175}176func (p *fileParser) parseInterface(name, pkg string, it *ast.InterfaceType) (*model.Interface, error) {177	intf := &model.Interface{Name: name}178	for _, field := range it.Methods.List {179		switch v := field.Type.(type) {180		case *ast.FuncType:181			if nn := len(field.Names); nn != 1 {182				return nil, fmt.Errorf("expected one name for interface %v, got %d", intf.Name, nn)183			}184			m := &model.Method{185				Name: field.Names[0].String(),186			}187			var err error188			m.In, m.Variadic, m.Out, err = p.parseFunc(pkg, v)189			if err != nil {190				return nil, err191			}192			intf.Methods = append(intf.Methods, m)193		case *ast.Ident:194			// Embedded interface in this package.195			ei := p.auxInterfaces[pkg][v.String()]196			if ei == nil {197				if ei = p.importedInterfaces[pkg][v.String()]; ei == nil {198					return nil, p.errorf(v.Pos(), "unknown embedded interface %s", v.String())199				}200			}201			eintf, err := p.parseInterface(v.String(), pkg, ei)202			if err != nil {203				return nil, err204			}205			// Copy the methods.206			// TODO: apply shadowing rules.207			for _, m := range eintf.Methods {208				intf.Methods = append(intf.Methods, m)209			}210		case *ast.SelectorExpr:211			// Embedded interface in another package.212			fpkg, sel := v.X.(*ast.Ident).String(), v.Sel.String()213			epkg, ok := p.imports[fpkg]214			if !ok {215				return nil, p.errorf(v.X.Pos(), "unknown package %s", fpkg)216			}217			ei := p.auxInterfaces[fpkg][sel]218			if ei == nil {219				fpkg = epkg220				if _, ok = p.importedInterfaces[epkg]; !ok {221					if err := p.parsePackage(epkg); err != nil {222						return nil, p.errorf(v.Pos(), "could not parse package %s: %v", fpkg, err)223					}224				}225				if ei = p.importedInterfaces[epkg][sel]; ei == nil {226					return nil, p.errorf(v.Pos(), "unknown embedded interface %s.%s", fpkg, sel)227				}228			}229			eintf, err := p.parseInterface(sel, fpkg, ei)230			if err != nil {231				return nil, err232			}233			// Copy the methods.234			// TODO: apply shadowing rules.235			for _, m := range eintf.Methods {236				intf.Methods = append(intf.Methods, m)237			}238		default:239			return nil, fmt.Errorf("don't know how to mock method of type %T", field.Type)240		}241	}242	return intf, nil243}244func (p *fileParser) parseFunc(pkg string, f *ast.FuncType) (in []*model.Parameter, variadic *model.Parameter, out []*model.Parameter, err error) {245	if f.Params != nil {246		regParams := f.Params.List247		if isVariadic(f) {248			n := len(regParams)249			varParams := regParams[n-1:]250			regParams = regParams[:n-1]251			vp, err := p.parseFieldList(pkg, varParams)252			if err != nil {253				return nil, nil, nil, p.errorf(varParams[0].Pos(), "failed parsing variadic argument: %v", err)254			}255			variadic = vp[0]256		}257		in, err = p.parseFieldList(pkg, regParams)258		if err != nil {259			return nil, nil, nil, p.errorf(f.Pos(), "failed parsing arguments: %v", err)260		}261	}262	if f.Results != nil {263		out, err = p.parseFieldList(pkg, f.Results.List)264		if err != nil {265			return nil, nil, nil, p.errorf(f.Pos(), "failed parsing returns: %v", err)266		}267	}268	return269}270func (p *fileParser) parseFieldList(pkg string, fields []*ast.Field) ([]*model.Parameter, error) {271	nf := 0272	for _, f := range fields {273		nn := len(f.Names)274		if nn == 0 {275			nn = 1 // anonymous parameter276		}277		nf += nn278	}279	if nf == 0 {280		return nil, nil281	}282	ps := make([]*model.Parameter, nf)283	i := 0 // destination index284	for _, f := range fields {285		t, err := p.parseType(pkg, f.Type)286		if err != nil {287			return nil, err288		}289		if len(f.Names) == 0 {290			// anonymous arg291			ps[i] = &model.Parameter{Type: t}292			i++293			continue294		}295		for _, name := range f.Names {296			ps[i] = &model.Parameter{Name: name.Name, Type: t}297			i++298		}299	}300	return ps, nil301}302func (p *fileParser) parseType(pkg string, typ ast.Expr) (model.Type, error) {303	switch v := typ.(type) {304	case *ast.ArrayType:305		ln := -1306		if v.Len != nil {307			x, err := strconv.Atoi(v.Len.(*ast.BasicLit).Value)308			if err != nil {309				return nil, p.errorf(v.Len.Pos(), "bad array size: %v", err)310			}311			ln = x312		}313		t, err := p.parseType(pkg, v.Elt)314		if err != nil {315			return nil, err316		}317		return &model.ArrayType{Len: ln, Type: t}, nil318	case *ast.ChanType:319		t, err := p.parseType(pkg, v.Value)320		if err != nil {321			return nil, err322		}323		var dir model.ChanDir324		if v.Dir == ast.SEND {325			dir = model.SendDir326		}327		if v.Dir == ast.RECV {328			dir = model.RecvDir329		}330		return &model.ChanType{Dir: dir, Type: t}, nil331	case *ast.Ellipsis:332		// assume we're parsing a variadic argument333		return p.parseType(pkg, v.Elt)334	case *ast.FuncType:335		in, variadic, out, err := p.parseFunc(pkg, v)336		if err != nil {337			return nil, err338		}339		return &model.FuncType{In: in, Out: out, Variadic: variadic}, nil340	case *ast.Ident:341		if v.IsExported() {342			// `pkg` may be an aliased imported pkg343			// if so, patch the import w/ the fully qualified import344			maybeImportedPkg, ok := p.imports[pkg]345			if ok {346				pkg = maybeImportedPkg347			}348			// assume type in this package349			return &model.NamedType{Package: pkg, Type: v.Name}, nil350		} else {351			// assume predeclared type352			return model.PredeclaredType(v.Name), nil353		}354	case *ast.InterfaceType:355		if v.Methods != nil && len(v.Methods.List) > 0 {356			return nil, p.errorf(v.Pos(), "can't handle non-empty unnamed interface types")357		}358		return model.PredeclaredType("interface{}"), nil359	case *ast.MapType:360		key, err := p.parseType(pkg, v.Key)361		if err != nil {362			return nil, err363		}364		value, err := p.parseType(pkg, v.Value)365		if err != nil {366			return nil, err367		}368		return &model.MapType{Key: key, Value: value}, nil369	case *ast.SelectorExpr:370		pkgName := v.X.(*ast.Ident).String()371		pkg, ok := p.imports[pkgName]372		if !ok {373			return nil, p.errorf(v.Pos(), "unknown package %q", pkgName)374		}375		return &model.NamedType{Package: pkg, Type: v.Sel.String()}, nil376	case *ast.StarExpr:377		t, err := p.parseType(pkg, v.X)378		if err != nil {379			return nil, err380		}381		return &model.PointerType{Type: t}, nil382	case *ast.StructType:383		if v.Fields != nil && len(v.Fields.List) > 0 {384			return nil, p.errorf(v.Pos(), "can't handle non-empty unnamed struct types")385		}386		return model.PredeclaredType("struct{}"), nil387	}388	return nil, fmt.Errorf("don't know how to parse type %T", typ)389}390// importsOfFile returns a map of package name to import path391// of the imports in file.392func importsOfFile(file *ast.File) map[string]string {393	/* We have to make guesses about some imports, because imports are not required394	 * to have names. Named imports are always certain. Unnamed imports are guessed395	 * to have a name of the last path component; if the last path component has dots,396	 * the first dot-delimited field is used as the name.397	 */398	m := make(map[string]string)399	for _, is := range file.Imports {400		var pkg string401		importPath := is.Path.Value[1 : len(is.Path.Value)-1] // remove quotes402		if is.Name != nil {403			if is.Name.Name == "_" {404				continue405			}406			pkg = removeDot(is.Name.Name)...

1import (2func main() {3    fset := token.NewFileSet()4    node, err := parser.ParseFile(fset, "1.go", nil, parser.ImportsOnly)5    if err != nil {6        panic(err)7    }8    for _, spec := range node.Imports {9        fmt.Println(spec.Path.Value)10    }11}12import (13func main() {14    fset := token.NewFileSet()15    node, err := parser.ParseFile(fset, "2.go", nil, parser.ImportsOnly)16    if err != nil {17        panic(err)18    }19    for _, spec := range node.Imports {20        fmt.Println(spec.Path.Value)21    }22}23import (24func main() {25    fset := token.NewFileSet()26    node, err := parser.ParseFile(fset, "3.go", nil, parser.ImportsOnly)27    if err != nil {28        panic(err)29    }30    for _, spec := range node.Imports {31        fmt.Println(spec.Path.Value)32    }33}34Working of importsOfFile method35func importsOfFile(fset *token.FileSet, filename string, err *error) *ast.File {36    f, err1 := parser.ParseFile(fset, filename, nil, parser.ImportsOnly)37    if err1 != nil {38    }39}40The importsOfFile method

1import (2func main() {3    imports, err := importsOfFile(filePath)4    if err != nil {5        fmt.Println(err)6    }7    fmt.Println(imports)8}9import (10func main() {11    imports, err := importsOfFile(filePath)12    if err != nil {13        fmt.Println(err)14    }15    fmt.Println(imports)16}

1import (2func main() {3    if len(os.Args) != 2 {4        fmt.Println("Usage: go run 1.go <file_name>")5        os.Exit(1)6    }7    mainObj := mainClass{}8    imports := mainObj.importsOfFile(fileName)9    fmt.Println("Imports of file", fileName, "are:")10    for _, imp := range imports {11        fmt.Println(imp)12    }13}14import (15func (m *mainClass) importsOfFile(fileName string) []string {16    file, err := os.Open(fileName)17    if err != nil {18        fmt.Println("Error opening file", fileName)19        os.Exit(1)20    }21    defer file.Close()22    var imports []string23    importRegex := regexp.MustCompile(`^import\s+\(\s*$`)24    importLineRegex := regexp.MustCompile(`^\s*".+"\s*$`)25    importEndRegex := regexp.MustCompile(`^\s*\)\s*$`)26    for {27        line, err := file.ReadString('28        if err != nil {29        }30        if importRegex.MatchString(line) {31            for {32                line, err = file.ReadString('33                if err != nil {34                }35                if importLineRegex.MatchString(line) {36                    imports = append(imports, line)37                } else if importEndRegex.MatchString(line) {38                }39            }40        }41    }42    return imports43}44How to get imports of a file in Go?

1import (2func main() {3	importsOfFile(path)4}5func importsOfFile(path string) {6	file, err := os.Open(path)7	if err != nil {8		log.Fatal(err)9	}10	defer file.Close()11	buf := make([]byte, 1024)12	n, err := file.Read(buf)13	if err != nil {14		log.Fatal(err)15	}16	lines := strings.Split(string(buf[:n]), "17	for _, line := range lines {18		if strings.HasPrefix(line, "import") {19			line = strings.TrimPrefix(line, "import")20			line = strings.Replace(line, "\"", "", -1)21			line = strings.Replace(line, "(", "", -1)22			line = strings.Replace(line, ")", "", -1)23			packages := strings.Split(line, " ")24			for _, pkg := range packages {25				if pkg != "" {26					fmt.Println(pkg)27				}28			}29		}30	}31}

1import (2func main() {3	fmt.Println("File Path: ", file_path)4	file, err := os.Open(file_path)5	if err != nil {6		fmt.Println("Error: ", err)7	}8	defer file.Close()9	imports := importsOfFile(file)10	fmt.Println("Imports: ", imports)11}12import (13func importsOfFile(file *os.File) []string {14	fset := token.NewFileSet()15	f, err := parser.ParseFile(fset, "", file, parser.ImportsOnly)16	if err != nil {17		fmt.Println("Error: ", err)18	}19	imports := []string{}20	for _, s := range f.Imports {21		imports = append(imports, s.Path.Value[1:len(s.Path.Value)-1])22	}23	return imports24}25import (26func importsOfFile(file *os.File) []string {27	fset := token.NewFileSet()28	f, err := parser.ParseFile(fset, "", file, parser.ImportsOnly)29	if err != nil {30		fmt.Println("Error: ", err)31	}32	imports := []string{}33	for _, s := range f.Imports {34		imports = append(imports, s.Path.Value[1:len(s.Path.Value)-1])35	}36	return imports37}38import (39func importsOfFile(file *os.File) []string {40	fset := token.NewFileSet()41	f, err := parser.ParseFile(fset,

1import (2func main() {3	cwd, _ := filepath.Abs(".")4	imports := importsOfFile(cwd)5	for _, imp := range imports {6		fmt.Println(imp)7	}8}9func importsOfFile(dir string) []string {10	pkg, _ := ctx.ImportDir(dir, 0)11	var imports []string12	for _, imp := range pkg.Imports {13		imports = append(imports, strings.Replace(imp, "vendor/", "", 1))14	}15	return imports16}17import (18func main() {19	cwd, _ := filepath.Abs(".")20	imports := importsOfFile(cwd)21	for _, imp := range imports {22		fmt.Println(imp)23	}24}25func importsOfFile(dir string) []string {26	pkg, _ := ctx.ImportDir(dir, 0)27	var imports []string28	for _, imp := range pkg.Imports {29		imports = append(imports, strings.Replace(imp, "vendor/", "", 1))30	}31	return imports32}33import (34func main() {35	cwd, _ := filepath.Abs(".")36	imports := importsOfFile(cwd)37	for _, imp := range imports {38		fmt.Println(imp)39	}40}41func importsOfFile