TODO lang:Go · golang/go — 2,626 matches

src/cmd/compile/internal/noder/reader.go GO 51 matches · showing 5 view file →

	rangeLitGen int
	// TODO(mdempsky): The state below is all specific to reading
	// function bodies. It probably makes sense to split it out
	// separately so that it doesn't take up space in every reader

· · ·

	// to "any".
	// TODO(mdempsky): Restore consistency check to make sure folding to
	// "any" is safe. This is unfortunately tricky, because a pure
	// interface can reference impure interfaces too, including

· · ·

				setType(name, shapeSig(name.Func, r.dict))
			} else {
				todoDicts = append(todoDicts, func() {
					r.dict.shapedObj = pr.objIdx(idx, implicits, explicits, true).(*ir.Name)
				})

· · ·

		if r.hasTypeParams() && !r.dict.shaped {
			todoDicts = append(todoDicts, func() {
				r.dict.shapedObj = pr.objIdx(idx, implicits, explicits, true).(*ir.Name)
			})

· · ·

	// Otherwise, we simply use the type's underlying type as its shape.
	//
	// TODO(mdempsky): It should be possible to do much more aggressive
	// shaping still; e.g., collapsing all pointer-shaped types into a
	// common type, collapsing scalars of the same size/alignment into a

+ 46 more matches in this file

src/cmd/compile/internal/ssagen/ssa.go GO 51 matches · showing 5 view file →

			return abi0
		case obj.ABIInternal:
			// TODO(austin): Clean up the nomenclature here.
			// It's not clear that "abi1" is ABIInternal.
			return abi1

· · ·

	a := abi0
	if fn != nil {
		if fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
			a = abi1
		}

· · ·

		}
		htmlWriter = ssahtml.NewHTMLWriter(ssaDF, s.f, ssaDumpCFG, compiler.Passes())
		// TODO: generate and print a mapping from nodes to values and blocks
		dumpSourcesColumn(htmlWriter, fn)
		htmlWriter.WriteAST("AST", astBuf)

· · ·

		// preceding the deferreturn/ret code that we don't track correctly.
		//
		// TODO this restriction can be removed given adjusted offset in computeDeferReturn in cmd/link/internal/ld/pcln.go
		s.hasOpenDefers = false
	}

· · ·

	}
	s.sp = s.entryNewValue0(ssaop.OpSP, types.Types[types.TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
	s.sb = s.entryNewValue0(ssaop.OpSB, types.Types[types.TUINTPTR])

+ 46 more matches in this file

src/cmd/compile/internal/ssacompile/regalloc.go GO 22 matches · showing 5 view file →

// x is now a spilled value and a restore must appear before its first use.
// TODO
// Use an affinity graph to mark two values which should use the

· · ·

// of x3 not dominated by the definition of x3, and the CX->BX copy
// will have no use (so don't run deadcode after regalloc!).
// TODO: maybe we should introduce these extra phis?
package ssacompile

· · ·

type endReg struct {
	r ssaop.Register
	v *ssa.Value // pre-regalloc value held in this register (TODO: can we use ID here?)
	c *ssa.Value // cached version of the value
}

· · ·

	// Pick a value to spill. Spill the value with the
	// farthest-in-the-future use.
	// TODO: Prefer registers with already spilled Values?
	// TODO: Modify preference using affinity graph.
	// TODO: if a single value is in multiple registers, spill one of them

· · ·

	// TODO: Modify preference using affinity graph.
	// TODO: if a single value is in multiple registers, spill one of them
	// before spilling a value in just a single register.

+ 17 more matches in this file

src/cmd/compile/internal/ssacompile/prove.go GO 17 matches · showing 5 view file →

	// For each slice s, a map from s to a len(s)/cap(s) value (if any)
	// TODO: check if there are cases that matter where we have
	// more than one len(s) for a slice. We could keep a list if necessary.
	lens map[ssa.ID]*ssa.Value

· · ·

	// the posets will not notice.
	if ft.recurseCheck[v.ID] {
		// This should only happen for unsatisfiable cases. TODO: check
		return
	}

· · ·

	ft.limits[v.ID] = lim
	if v.Block.Func.Pass.Debug > 2 {
		// TODO: pos is probably wrong. This is the position where v is defined,
		// not the position where we learned the fact about it (which was
		// probably some subsequent compare+branch).

· · ·

				r ^= lt | gt | eq
			}
			// TODO: v.Block is wrong?
			addRestrictions(v.Block, ft, d, v.Args[0], v.Args[1], r)
		}

· · ·

				}
				ft.update(v.Block, v.Args[0], v.Args[1], unsigned, r)
				// TODO: v.Block is wrong here
			}
		}

+ 12 more matches in this file

src/cmd/compile/internal/noder/writer.go GO 24 matches · showing 5 view file →

// function body reading code.
// TODO(mdempsky): Add an importer for Unified IR to the x/tools repo,
// and better document the file format boundary between public and
// private data.

· · ·

	sig *types2.Signature
	// TODO(mdempsky): We should be able to prune localsIdx whenever a
	// scope closes, and then maybe we can just use the same map for
	// storing the TypeParams too (as their TypeName instead).

· · ·

	pos := p.Pos()
	// TODO(mdempsky): Track down the remaining cases here and fix them.
	if !w.Bool(pos.IsKnown()) {
		return

· · ·

	}
	// TODO(mdempsky): Delta encoding.
	w.posBase(pos.Base())
	w.Uint(pos.Line())

· · ·

		w.String("unsafe")
	default:
		// TODO(mdempsky): Write out pkg.Path() for curpkg too.
		var path string
		if pkg != w.p.curpkg {

+ 19 more matches in this file

src/runtime/malloc.go GO 26 matches · showing 5 view file →

	// 48 bits because this uses too much address space for older
	// iOS versions.
	// TODO(mknyszek): Once iOS <14 is deprecated, promote ios/arm64
	// to a 48-bit address space like every other arm64 platform.
	//

· · ·

		// Failed. Discard this hint and try the next.
		//
		// TODO: This would be cleaner if sysReserve could be
		// told to only return the requested address. In
		// particular, this is already how Windows behaves, so

· · ·

// enabled, and none of the memory sanitizers should be enabled. We allow the race detector,
// in contrast to sizeSpecializedMallocEnabled.
// TODO(thepudds): it would be nice to check Valgrind integration, though there are some hints
// there might not be any canned tests in tree for Go's integration with Valgrind.
const runtimeFreegcEnabled = goexperiment.RuntimeFreegc && !asanenabled && !msanenabled && !valgrindenabled

· · ·

		// value is aligned to 8 bytes and does not cause a fault on
		// atomic access. See issue 37262.
		// TODO(mknyszek): Remove this workaround if/when issue 36606
		// is resolved.
		off = alignUp(off, 8)

· · ·

	// will update the mem profile on the "free" side.
	//
	// TODO(mknyszek): We should really count the header as part
	// of gc_sys or something. The code below just pretends it is
	// internal fragmentation and matches the GC's accounting by

+ 21 more matches in this file

src/cmd/go/internal/work/exec.go GO 19 matches · showing 5 view file →

		var err error
		if a.Actor != nil && (a.Failed == nil || a.IgnoreFail) {
			// TODO(matloob): Better action descriptions
			desc := "Executing action (" + a.Mode
			if a.Package != nil {

· · ·

		}
		// TODO(rsc): Convince compiler team not to add more magic environment variables,
		// or perhaps restrict the environment variables passed to subprocesses.
		// Because these are clumsy, undocumented special-case hacks

· · ·

	// Input files.
	// TODO(matloob): once the build action depends on the cgo actions, we can
	// use those actions' outputs instead of the file names and hashes.
	inputFiles := str.StringList(

· · ·

		// (https://go.dev/issue/47257) and no longer support GOROOT_FINAL
		// (https://go.dev/issue/62047).
		// TODO(bcmills): Figure out whether this behavior is still useful.
		//
		// b.WorkDir is always either trimmed or rewritten to

· · ·

			}
		}
		// TODO(rsc): Should we include the SWIG version?
	}
}

+ 14 more matches in this file

src/net/http/internal/http2/server.go GO 18 matches · showing 5 view file →

// license that can be found in the LICENSE file.
// TODO: turn off the serve goroutine when idle, so
// an idle conn only has the readFrames goroutine active. (which could
// also be optimized probably to pin less memory in crypto/tls). This

· · ·

// returns.
// TODO (maybe): add a mechanism for Handlers to going into
// half-closed-local mode (rw.(io.Closer) test?) but not exit their
// handler, and continue to be able to read from the

· · ·

	firstSettingsTimeout  = 2 * time.Second // should be in-flight with preface anyway
	handlerChunkWriteSize = 4 << 10
	defaultMaxStreams     = 250 // TODO: make this 100 as the GFE seems to?
	// maxQueuedControlFrames is the maximum number of control frames like

· · ·

			// addresses during development.
			//
			// TODO: optionally enforce? Or enforce at the time we receive
			// a new request, and verify the ServerName matches the :authority?
			// But that precludes proxy situations, perhaps.

· · ·

// errno returns v's underlying uintptr, else 0.
//
// TODO: remove this helper function once http2 can use build
// tags. See comment in isClosedConnError.
func errno(v error) uintptr {

+ 13 more matches in this file

src/cmd/compile/internal/syntax/printer.go GO 12 matches · showing 5 view file →

	case _Name,
		_Break, _Continue, _Fallthrough, _Return,
		/*_Inc, _Dec,*/ _Rparen, _Rbrack, _Rbrace: // TODO(gri) fix this
		return true
	}

· · ·

}
// TODO(gri) provide table of []byte values for all tokens to avoid repeated string conversion
func (p *printer) addWhitespace(kind ctrlSymbol, text string) {

· · ·

	case newline:
		p.lastTok = 0
		// TODO(gri) do we need to handle /*-style comments containing newlines here?
	}
}

· · ·

		// 	}
		// case eolComment:
		// 	// TODO(gri) act depending on sawNewline
		default:
			panic("unreachable")

· · ·

		// 		prev = comment
		// 	}
		// 	// TODO(gri) should check that line comments are always followed by newline
		default:
			panic("unreachable")

+ 7 more matches in this file

src/net/http/internal/http2/transport.go GO 16 matches · showing 5 view file →

		cs.closeReqBodyLocked()
	}
	// TODO(dneil): Clean up tests where cs.cc.cond is nil.
	if cs.cc.cond != nil {
		// Wake up writeRequestBody if it is waiting on flow control.

· · ·

	cc.flow.add(int32(initialWindowSize))
	// TODO: adjust this writer size to account for frame size +
	// MTU + crypto/tls record padding.
	cc.bw = bufio.NewWriter(stickyErrWriter{

· · ·

	cc.closedOnIdle = true
	nextID := cc.nextStreamID
	// TODO: do clients send GOAWAY too? maybe? Just Close:
	cc.mu.Unlock()

· · ·

	}
	// TODO: write h12Compare test showing whether
	// Request.Body is closed by the Transport,
	// and in multiple cases: server replies <=299 and >299

· · ·

			err = cc.fr.WriteData(cs.ID, sentEnd, data)
			if err == nil {
				// TODO(bradfitz): this flush is for latency, not bandwidth.
				// Most requests won't need this. Make this opt-in or
				// opt-out?  Use some heuristic on the body type? Nagel-like

+ 11 more matches in this file

src/go/parser/parser.go GO 11 matches · showing 5 view file →

func (p *parser) parseParamDecl(name *ast.Ident, typeSetsOK bool) (f field) {
	// TODO(rFindley) refactor to be more similar to paramDeclOrNil in the syntax
	// package
	if p.trace {

· · ·

	default:
		// TODO(rfindley): this is incorrect in the case of type parameter lists
		//                 (should be "']'" in that case)
		p.errorExpected(p.pos, "')'")

· · ·

			}
			// use T instead of invalid ...T
			// TODO(gri) would like to use `f.typ = t.Elt` but that causes problems
			//           with the resolver in cases of reuse of the same identifier
			f.typ = &ast.BadExpr{From: t.Pos(), To: t.End()}

· · ·

				p.error(lbrack, "interface method must have no type parameters")
				// TODO(rfindley) refactor to share code with parseFuncType.
				params := p.parseParameters(false)
				results := p.parseParameters(true)

· · ·

			} else {
				// embedded instantiated type
				// TODO(rfindley) should resolve all identifiers in x.
				list := []ast.Expr{x}
				if p.atComma("type argument list", token.RBRACK) {

+ 6 more matches in this file

src/go/printer/nodes.go GO 10 matches · showing 5 view file →

// printed.
//
// TODO(gri): linebreak may add too many lines if the next statement at "line"
// is preceded by comments because the computation of n assumes
// the current position before the comment and the target position

· · ·

// expressions.
//
// TODO(gri) Consider rewriting this to be independent of []ast.Expr
// so that we can use the algorithm for any kind of list
//

· · ·

		// in general, use the entire node size to make the decision; for
		// key:value expressions, use the key size.
		// TODO(gri) for a better result, should probably incorporate both
		//           the key and the node size into the decision process
		useFF := true

· · ·

			if i > 0 {
				// don't do a line break (min == 0) if we are printing a list of types
				// TODO(gri) this doesn't work quite right if the list of types is
				//           spread across multiple lines
				min := 1

· · ·

			p.print(x.Op)
			if x.Op == token.RANGE {
				// TODO(gri) Remove this code if it cannot be reached.
				p.print(blank)
			}

+ 5 more matches in this file

src/cmd/go/internal/modload/init.go GO 11 matches · showing 5 view file →

// Variables set by other packages.
//
// TODO(#40775): See if these can be plumbed as explicit parameters.
var (
	// ExplicitWriteGoMod prevents LoadPackages, ListModules, and other functions

· · ·

			// Special case: we are outside a module, like 'go run x.go'.
			// Assume the local Go version.
			// TODO(#49228): Clean this up; see loadModFile.
			return gover.Local()
		}

· · ·

func modFilePath(modRoot string) string {
	// TODO(matloob): This seems incompatible with workspaces
	// (unless the user's intention is to replace all workspace modules' modfiles?).
	// Should we produce an error in workspace mode if cfg.ModFile is set?

· · ·

	// Clean up and annotate directories.
	// TODO(matloob): update x/mod to actually add module paths.
	for moddir, absmodroot := range missingModulePaths {
		_, f, err := ReadModFile(filepath.Join(absmodroot, "go.mod"), nil)

· · ·

	}
	if len(ld.modRoots) == 0 {
		// TODO(#49228): Instead of creating a fake module with an empty modroot,
		// make MainModules.Len() == 0 mean that we're in module mode but not inside
		// any module.

+ 6 more matches in this file

src/cmd/compile/internal/inline/inl.go GO 10 matches · showing 5 view file →

var (
	// List of all hot callee nodes.
	// TODO(prattmic): Make this non-global.
	candHotCalleeMap = make(map[*pgoir.IRNode]struct{})

· · ·

	// List of all hot call sites. CallSiteInfo.Callee is always nil.
	// TODO(prattmic): Make this non-global.
	candHotEdgeMap = make(map[pgoir.CallSiteInfo]struct{})

· · ·

	// alive information is lost during inlining.
	//
	// TODO(prattmic): This is handled on calls during escape analysis,
	// which is after inlining. Move prior to inlining so the keep-alive is
	// maintained after inlining.

· · ·

				// will miss those.
				//
				// TODO: in the case of a single-call closure, the inlining budget here is potentially much, much larger.
				//
				v.budget -= callee.Inl.Cost

· · ·

	case ir.ORECOVER:
		// TODO: maybe we could allow inlining of recover() now?
		v.reason = "call to recover"
		return true

+ 5 more matches in this file

src/cmd/compile/internal/reflectdata/reflect.go GO 11 matches · showing 5 view file →

		}
	} else {
		// TODO(mdempsky): We should be able to share these too (except
		// maybe when dynamic linking).
		sname = fmt.Sprintf("%s%s.%d", sname, types.LocalPkg.Prefix, dnameCount)

· · ·

		}
		// TODO(mdempsky): Investigate whether this still happens.
		// If we know we don't need to emit code for a type,
		// we should have a link-symbol index for it.

· · ·

		// See also TODO in NeedEmit.
		return lsym
	}

· · ·

	case types.TPTR:
		rt = rttype.PtrType
		// TODO: use rttype.Type for Elem() is ANY?
	case types.TSTRUCT:
		rt = rttype.StructType

· · ·

// create a dummy itab with zeroed-out method entries.
func writeITab(lsym *obj.LSym, typ, iface *types.Type, allowNonImplement bool) {
	// TODO(mdempsky): Fix methodWrapper, geneq, and genhash (and maybe
	// others) to stop clobbering these.
	oldpos, oldfn := base.Pos, ir.CurFunc

+ 6 more matches in this file

src/go/types/call.go GO 11 matches · showing 5 view file →

				// Rename type parameters for cases like f(g, g); this gives each
				// generic function argument a unique type identity (go.dev/issues/59956).
				// TODO(gri) Consider only doing this if a function argument appears
				//           multiple times, which is rare (possible optimization).
				atparams, tmp := check.renameTParams(call.Pos(), asig.TypeParams().list(), asig)

· · ·

		targs = check.infer(call, tparams, targs, sigParams, args, false, err)
		if targs == nil {
			// TODO(gri) If infer inferred the first targs[:n], consider instantiating
			//           the call signature for better error messages/gopls behavior.
			//           Perhaps instantiate as much as we can, also for arguments.

· · ·

			k := j + asig.TypeParams().Len()
			// targs[j:k] are the inferred type arguments for asig
			arg.typ_ = check.instantiateSignature(call.Pos(), arg.expr, asig, targs[j:k], nil) // TODO(gri) provide xlist if possible (partial instantiations)
			check.record(arg)                                                                  // record here because we didn't use the usual expr evaluators
			j = k

· · ·

		if index != nil {
			// TODO(gri) should provide actual type where the conflict happens
			check.errorf(e.Sel, AmbiguousSelector, "ambiguous selector %s.%s", x.expr, sel)
			goto Error

· · ·

		check.objDecl(obj) // ensure fully set-up signature
		check.addDeclDep(obj)
		// TODO(mark): Assert that sig.rparams is nil here?
		if x.mode() == typexpr {

+ 6 more matches in this file

src/simd/archsimd/_gen/simdgen/xed.go GO 11 matches · showing 5 view file →

}
// TODO: Doc. Returns Values with Def domains.
func loadXED(xedPath string) []*unify.Value {
	// TODO: Obviously a bunch more to do here.

· · ·

	// TODO: Obviously a bunch more to do here.
	db, err := xeddata.NewDatabase(xedPath)

· · ·

// operandAction defines whether this operand is read and/or written.
//
// TODO: Should this live in [xeddata.Operand]?
type operandAction struct {
	r  bool // Read

· · ·

	}
	// TODO: See xed_decoded_inst_operand_action. This might need to be more
	// complicated.
	action, ok := actionEncoding[op.Action]

· · ·

	}
	// TODO: BASE and SEG
	return nil, fmt.Errorf("unknown operand LHS %q in %q", lhs, operand)
}

+ 6 more matches in this file

src/cmd/go/internal/work/action.go GO 12 matches · showing 5 view file →

type Builder struct {
	WorkDir            string                    // the temporary work directory (ends in filepath.Separator)
	getVendorDir       func() string             // TODO(jitsu): remove this after we eliminate global module state
	actionCache        map[cacheKey]*Action      // a cache of already-constructed actions
	flagCache          map[[2]string]bool        // a cache of supported compiler flags

· · ·

			}
			if a.Package != nil {
				// TODO(rsc): Make this a unique key for a.Package somehow.
				a.json.Package = a.Package.ImportPath
			}

· · ·

// cacheAction looks up {mode, p} in the cache and returns the resulting action.
// If the cache has no such action, f() is recorded and returned.
// TODO(rsc): Change the second key from *load.Package to interface{},
// to make the caching in linkShared less awkward?
func (b *Builder) cacheAction(mode string, p *load.Package, f func() *Action) *Action {

· · ·

	// Use breadth-first search to find rebuilt-for-test packages
	// before the standard ones.
	// TODO(rsc): Eliminate the standard ones from the action graph,
	// which will require doing a little bit more rebuilding.
	workq := []*Action{a1}

· · ·

		a1 := workq[i]
		for _, a2 := range a1.Deps {
			// TODO(rsc): Find a better discriminator than the Mode strings, once the dust settles.
			if a2.Package == nil || (a2.Mode != "build-install" && a2.Mode != "build") || haveDep[a2.Package.ImportPath] {
				continue

+ 7 more matches in this file

src/cmd/compile/internal/escape/solve.go GO 26 matches · showing 5 view file →

	// Queue of locations to walk. Has enough room for b.allLocs
	// plus b.heapLoc, b.mutatorLoc, b.calleeLoc.
	todo := newQueue(len(b.allLocs) + 3)
	enqueue := func(loc *location) {

· · ·

				// which in some cases allows attrEscape to
				// propagate faster.
				todo.pushFront(loc)
			} else {
				todo.pushBack(loc)

· · ·

				todo.pushBack(loc)
			}
		}

· · ·

	for _, loc := range b.allLocs {
		todo.pushFront(loc)
		// TODO(thepudds): clean up setting queuedWalkAll.
		loc.queuedWalkAll = true

· · ·

		// TODO(thepudds): clean up setting queuedWalkAll.
		loc.queuedWalkAll = true
	}

+ 21 more matches in this file

src/encoding/gob/dec_helpers.go GO 17 matches · showing 5 view file →

	slice, ok := reflect.TypeAssert[[]bool](v)
	if !ok {
		// It is kind bool but not type bool. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]complex64](v)
	if !ok {
		// It is kind complex64 but not type complex64. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]complex128](v)
	if !ok {
		// It is kind complex128 but not type complex128. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]float32](v)
	if !ok {
		// It is kind float32 but not type float32. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]float64](v)
	if !ok {
		// It is kind float64 but not type float64. TODO: We can handle this unsafely.
		return false
	}

+ 12 more matches in this file

src/cmd/go/internal/doc/pkg.go GO 6 matches · showing 5 view file →

	astPkg := pkgs[pkg.Name]
	// TODO: go/doc does not include typed constants in the constants
	// list, which is what we want. For instance, time.Sunday is of type
	// time.Weekday, so it is defined in the type but not in the

· · ·

// bugs prints the BUGS information for the package.
// TODO: Provide access to TODOs and NOTEs as well (very noisy so off by default)?
func (pkg *Package) bugs() {
	if pkg.doc.Notes["BUG"] == nil {

· · ·

	// Print each spec only if there is at least one exported symbol in it.
	// (See issue 11008.)
	// TODO: Should we elide unexported symbols from a single spec?
	// It's an unlikely scenario, probably not worth the trouble.
	// TODO: Would be nice if go/doc did this for us.

· · ·

	// TODO: Would be nice if go/doc did this for us.
	specs := make([]ast.Spec, 0, len(value.Decl.Specs))
	var typ ast.Expr

· · ·

		for _, iMethod := range inter.Methods.List {
			// This is an interface, so there can be only one name.
			// TODO: Anonymous methods (embedding)
			if len(iMethod.Names) == 0 {
				continue

+ 1 more matches in this file

src/cmd/compile/internal/types2/infer.go GO 11 matches · showing 5 view file →

	// even though the type int was provided (not inferred) for P.
	//
	// TODO(gri) We might be able to finesse this in the error message reporting
	//           (which only happens in case of an error) and then avoid doing
	//           the substitution (which always happens).

· · ·

		}
		smap := makeSubstMap(tparams, targs)
		// TODO(gri): pass a poser here, rather than arg.Pos().
		inferred := check.subst(arg.Pos(), tpar, smap, nil, check.context())
		// CannotInferTypeArgs indicates a failure of inference, though the actual

· · ·

			// and continue, we may still be able to infer all
			// targs resulting in fewer follow-on errors.
			// TODO(gri) determine if we still need this check
			continue
		}

· · ·

					//    with the core type.
					if !u.unify(tx, core.typ, 0) {
						// TODO(gri) Type parameters that appear in the constraint and
						//           for which we have type arguments inferred should
						//           use those type arguments for a better error message.

· · ·

			// and we may get a missing method error below. Skip this step in this case.
			//
			// TODO(gri) We should be able continue even with a parameterized tx if we add
			// a simplify step beforehand (see below). This will require factoring out the
			// simplify phase so we can call it from here.

+ 6 more matches in this file

src/net/lookup_windows.go GO 9 matches · showing 5 view file →

	}
	// TODO(bradfitz,brainman): use ctx more. See TODO below.
	var family int32 = syscall.AF_UNSPEC

· · ·

		return r.addrs, r.err
	case <-ctx.Done():
		// TODO(bradfitz,brainman): cancel the ongoing
		// GetAddrInfoW? It would require conditionally using
		// GetAddrInfoEx with lpOverlapped, which requires

· · ·

	}
	// TODO(bradfitz): finish ctx plumbing
	if err := acquireThread(ctx); err != nil {
		return 0, newDNSError(mapErr(err), network+"/"+service, "")

· · ·

	}
	// TODO(bradfitz): finish ctx plumbing
	if err := acquireThread(ctx); err != nil {
		return "", newDNSError(mapErr(err), name, "")

· · ·

		return r.goLookupSRV(ctx, service, proto, name)
	}
	// TODO(bradfitz): finish ctx plumbing
	if err := acquireThread(ctx); err != nil {
		return "", nil, newDNSError(mapErr(err), name, "")

+ 4 more matches in this file

src/go/types/infer.go GO 11 matches · showing 5 view file →

	// even though the type int was provided (not inferred) for P.
	//
	// TODO(gri) We might be able to finesse this in the error message reporting
	//           (which only happens in case of an error) and then avoid doing
	//           the substitution (which always happens).

· · ·

		}
		smap := makeSubstMap(tparams, targs)
		// TODO(gri): pass a poser here, rather than arg.Pos().
		inferred := check.subst(arg.Pos(), tpar, smap, nil, check.context())
		// CannotInferTypeArgs indicates a failure of inference, though the actual

· · ·

			// and continue, we may still be able to infer all
			// targs resulting in fewer follow-on errors.
			// TODO(gri) determine if we still need this check
			continue
		}

· · ·

					//    with the core type.
					if !u.unify(tx, core.typ, 0) {
						// TODO(gri) Type parameters that appear in the constraint and
						//           for which we have type arguments inferred should
						//           use those type arguments for a better error message.

· · ·

			// and we may get a missing method error below. Skip this step in this case.
			//
			// TODO(gri) We should be able continue even with a parameterized tx if we add
			// a simplify step beforehand (see below). This will require factoring out the
			// simplify phase so we can call it from here.

+ 6 more matches in this file

src/encoding/gob/enc_helpers.go GO 16 matches · showing 5 view file →

	slice, ok := reflect.TypeAssert[[]bool](v)
	if !ok {
		// It is kind bool but not type bool. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]complex64](v)
	if !ok {
		// It is kind complex64 but not type complex64. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]complex128](v)
	if !ok {
		// It is kind complex128 but not type complex128. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]float32](v)
	if !ok {
		// It is kind float32 but not type float32. TODO: We can handle this unsafely.
		return false
	}

· · ·

	slice, ok := reflect.TypeAssert[[]float64](v)
	if !ok {
		// It is kind float64 but not type float64. TODO: We can handle this unsafely.
		return false
	}

+ 11 more matches in this file

`auth login`	both terms (AND is implicit)
`auth OR login`	either term
`NOT path:vendor`	exclude matches
`"exact phrase"`	quoted exact match
`/func\s+Test/`	regex
`handler~1`	fuzzy (Levenshtein 1)
`file:*_test.go`	filename glob
`path:pkg/auth/**`	full path glob
`lang:go`	language filter

Search any public repo from your terminal