Method parseGolangIdentifiers

convert.go:320–403

()

}

func (ts *Typescript) parseGolangIdentifiers() error {
	// Look for comments that indicate to ignore a type for typescript generation.
	// Comment format to skip typescript generation: `@typescript-ignore <ignored_type>`
	ignoreRegex := regexp.MustCompile("@typescript-ignore[:]?(?P<ignored_types>.*)")

	refPkgs := make([]*packages.Package, 0, len(ts.parsed.Pkgs))
	genPkgs := make([]*packages.Package, 0, len(ts.parsed.Pkgs))
	for _, pkg := range ts.parsed.Pkgs {
		if ts.parsed.Reference[pkg.PkgPath] {
			refPkgs = append(refPkgs, pkg)
			continue
		}
		genPkgs = append(genPkgs, pkg)
	}

	// always do gen packages first to know the references
	for _, pkg := range append(genPkgs, refPkgs...) {
		skippedTypes := make(map[string]struct{})
		for _, file := range pkg.Syntax {
			for _, comment := range file.Comments {
				for _, line := range comment.List {
					text := line.Text
					matches := ignoreRegex.FindStringSubmatch(text)
					ignored := ignoreRegex.SubexpIndex("ignored_types")
					if len(matches) >= ignored && matches[ignored] != "" {
						arr := strings.Split(matches[ignored], ",")
						for _, s := range arr {
							skippedTypes[strings.TrimSpace(s)] = struct{}{}
						}
					}
				}
			}
		}

		allIdents := pkg.Types.Scope().Names()
		for _, ident := range allIdents {
			if _, ok := skippedTypes[ident]; ok {
				continue
			}

			obj := pkg.Types.Scope().Lookup(ident)

			if !obj.Exported() {
				continue
			}

			// Skip by qualified name
			if _, ok := ts.skip[obj.Type().String()]; ok {
				continue
			}

			if ts.parsed.Reference[pkg.PkgPath] {
				if !ts.parsed.referencedTypes.IsReferenced(obj) {
					continue
				}
			}
			if ts.parsed.referencedTypes.IsGenerated(obj) {
				continue