Method ObservePackage

inference/engine.go:183–305

ObservePackage observes all the annotations and assertions computed locally about the current package. The assertions are sorted based on whether they are already known to trigger without reliance on annotation sites, such as `x` in `x = nil; x.f`, which will generate `SingleAssertionFailure`s, whet

(pkgFullTriggers []annotation.FullTrigger)

// observeImplication. Before all assertions are sorted and handled thus, the annotations read for
// the package are iterated over and observed via calls to observeSiteExplanation as a <Val>BecauseAnnotation.
func (e *Engine) ObservePackage(pkgFullTriggers []annotation.FullTrigger) {
	// As Step 1, we do a pre-analysis of "guard missing" triggers to verify if their dereferences are always nil-safe,
	// and hence can be deleted to not report a false positive error. Specifically, this analyis of "always safe" paths
	// is focussed on the rich check effect functions, namely error returning functions and ok-returning functions.
	// The process is to find all guard missing triggers reaching a function return site, and then check if all the return triggers
	// to that function site are non-nil. If so, we can safely delete all the guard-missing triggers for this function site.
	triggersToBeDeleted := make(map[int]bool)
	mapSiteGuardMissing, mapSiteReturn := e.mapGuardMissingAndReturnToFuncSite(pkgFullTriggers)
	for site, guardMissingIndices := range mapSiteGuardMissing {
		if returnIndices, ok := mapSiteReturn[site]; ok {
			// Check if all the return triggers to this function site are non-nil.
			nonnilCnt := 0
			for _, index := range returnIndices {
				returnTrigger := pkgFullTriggers[index]
				if returnTrigger.Producer.Annotation.Kind() != annotation.Never {
					// break early if we find a potentially nilable trigger
					break
				}
				nonnilCnt++
			}

			if nonnilCnt == len(returnIndices) {
				// If all return triggers are non-nil, then we can safely delete all the guard-missing triggers
				// for this function site.
				for _, index := range guardMissingIndices {
					triggersToBeDeleted[index] = true
				}
			}
		}
	}
	// Add all placeholder UseAsReturnForAlwaysSafePath triggers to triggersToBeDeleted
	for _, indices := range mapSiteReturn {
		for _, index := range indices {
			triggersToBeDeleted[index] = true
		}
	}

	// Filter out the triggers that are to be deleted.
	pkgFullTriggers = slices.DeleteFunc(pkgFullTriggers, func(t annotation.FullTrigger) bool {
		index := slices.Index(pkgFullTriggers, t)
		return triggersToBeDeleted[index]
	})

	// Separate out triggers with UseAsNonErrorRetDependentOnErrorRetNilability consumer from other triggers.
	// This is needed since whether UseAsNonErrorRetDependentOnErrorRetNilability triggers should be fired
	// is dependent on their corresponding UseAsErrorRetWithNilabilityUnknown triggers. By this separation,
	// we can process all other triggers, including UseAsErrorRetWithNilabilityUnknown, first, and once
	// their nilability status is known, then filter out the unnecessary UseAsNonErrorRetDependentOnErrorRetNilability
	// triggers, and run the pkg inference process again only for the remainder triggers.
	// Steps 2--4 below depict this approach in more detail.
	var (
		nonErrRetTriggers []annotation.FullTrigger
		// In most cases all triggers will be stored in otherTriggers, so we set a proper capacity.
		otherTriggers = make([]annotation.FullTrigger, 0, len(pkgFullTriggers))
	)

	for _, t := range pkgFullTriggers {
		if _, ok := t.Consumer.Annotation.(*annotation.UseAsNonErrorRetDependentOnErrorRetNilability); ok {