//nolint:unused // U1000 see comment above, we know it's unused normally.
func (fakeTestDeps) StartCPUProfile(io.Writer) error {
	return nil
}

//nolint:unused // U1000 see comment above, we know it's unused normally.
func (fakeTestDeps) StopCPUProfile() {}

//nolint:unused // U1000 see comment above, we know it's unused normally.
func (fakeTestDeps) StartTestLog(io.Writer) {}

//nolint:unused // U1000 see comment above, we know it's unused normally.

        def provider = new UnavailablePlatformToolProvider(Stub(OperatingSystemInternal), new ToolChainAvailability().unavailable("don't know how to build this thing"))

        expect:
        def formatter = new TreeFormatter()
        provider.explain(formatter)
        formatter.toString() == "don't know how to build this thing"
    }

    def "tool lookup returns same failure"() {

        }
        if (!(OperatingSystem.current().unix || OperatingSystem.current().windows)) {
            throw new RuntimeException("This implementation does not know how to forcefully kill a process on os: " + OperatingSystem.current())
        }
        execute(killArgs(pid, killTree), killScript(pid, killTree))
    }

    // Only supported on *nix platforms

# go.mod file. Otherwise, we don't actually know whether the module was written
# against Go 1.11 or 1.16. We would have to update the go.mod file to clarify,
# and as of Go 1.16 we don't update the go.mod file by default.
#
# If we set -mod=vendor explicitly, we shouldn't apply the Go 1.14
# consistency check, because — again — we don't know whether we're in a 1.11
# module or a bad-script-edited 1.16 module.

                encoder.writeBoolean(value.isChanging);
                encoder.writeLong(value.createTimestamp);
                break;
            default:
                throw new IllegalArgumentException("Don't know how to serialize meta-data entry: " + value);
        }
    }

    @Override
    public ModuleMetadataCacheEntry read(Decoder decoder) throws Exception {
        byte type = decoder.readByte();
        switch (type) {

    ```

But then we get a `dict` in the parameter `commons` of the *path operation function*.

And we know that editors can't provide a lot of support (like completion) for `dict`s, because they can't know their keys and value types.

We can do better...

## What makes a dependency

Up to now you have seen dependencies declared as functions.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// initialization cycles

package init0

// initialization cycles (we don't know the types)
const (
	s0 /* ERROR "initialization cycle: s0 refers to itself" */ = s0

	x0 /* ERROR "initialization cycle for x0" */ = y0
	y0 = x0

	a0 = b0
	b0 /* ERROR "initialization cycle for b0" */ = c0

				case isAttr(t):
					pos = key
				case types.IsInterface(t):
					// As we do not do dataflow, we do not know what the dynamic type is.
					// But we might be able to learn enough to make a decision.
					if types.AssignableTo(stringType, t) {
						// t must be an empty interface. So it can also be an Attr.
						// We don't know enough to make an assumption.
						pos = unknown
						continue

    /**
     * Classes to compile are all classes that we know from Java sources that will be compiled.
     * These classes are deleted before a compilation and are not passed to Java compiler (their sources are passed to a compiler).
     * We only need them in {@link CompilationClassBackupService} so we know what files don't need a backup.
     */
    Set<String> getClassesToCompile();

     *   <li>If this field's value is some other thread object, we know that it's not our thread.
     *   <li>If this field's value == null because it originally belonged to another thread and that
     *       thread cleared it, we still know that it's not associated with our thread
     *   <li>If this field's value == null because it was associated with our thread and was
     *       cleared, we know that we're not executing inline any more
     * </ul>