SimulatedJavaCallLocation   | INDIRECT_CALL   | 'indirectly'   | SimulatedJavaCallLocation.indirectly()
        SimulatedJavaCallLocation   | INDIRECT_CALL_2 | 'indirectly2'  | SimulatedJavaCallLocation.indirectly2()
        SimulatedGroovyCallLocation | DIRECT_CALL     | 'create'       | SimulatedGroovyCallLocation.create()
        SimulatedGroovyCallLocation | INDIRECT_CALL   | 'indirectly'   | SimulatedGroovyCallLocation.indirectly()

    }

    static SimulatedSingleMessageLogger.TestFeatureUsage indirectly() {
        return SimulatedSingleMessageLogger.indirectly(SimulatedSingleMessageLogger.INDIRECT_CALL);
    }

    static SimulatedSingleMessageLogger.TestFeatureUsage indirectly2() {
        return SimulatedSingleMessageLogger.indirectlySecondLevel(SimulatedSingleMessageLogger.INDIRECT_CALL_2);
    }

    public static final String INDIRECT_CALL = "indirect call";
    public static final String INDIRECT_CALL_2 = "second-level indirect call";

    public static TestFeatureUsage indirectlySecondLevel(String message) {
        return indirectly(message);
    }

    public static TestFeatureUsage indirectly(String message) {
        return nagUserWith(message);
    }

        return SimulatedSingleMessageLogger.nagUserWith(SimulatedSingleMessageLogger.DIRECT_CALL)
    }

    static FeatureUsage indirectly() {
        return SimulatedSingleMessageLogger.indirectly(SimulatedSingleMessageLogger.INDIRECT_CALL)
    }

    static FeatureUsage indirectly2() {
        return SimulatedSingleMessageLogger.indirectlySecondLevel(SimulatedSingleMessageLogger.INDIRECT_CALL_2)
    }

    /**
     * Gets the downstream projects of the specified project. A downstream project is a project that directly or
     * indirectly depends on the given project.
     *
     * @param project The project whose downstream projects should be retrieved, must not be {@code null}.
     * @param transitive A flag whether to retrieve all direct and indirect downstream projects or just the immediate
     *            downstream projects.

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

// This directory contains a pair of packages that triggers a compiler
// crash in gccgo (problem with tracking indirectly referenced
// packages during exporting). See issue 32778 for details.

apiVersion: release-notes/v2
kind: feature
area: istioctl
issue:
  - 26080

releaseNotes:
- |

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Declarations for operating systems implementing time.now
// indirectly, in terms of walltime and nanotime assembly.

//go:build !faketime && !windows && !(linux && amd64)

package runtime

import _ "unsafe" // for go:linkname

// time_now should be an internal detail,

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

// Like ifacemethod2.go, this tests that a method *is* live
// if the type is "indirectly" converted to an interface
// using reflection with a method descriptor as intermediate.

package main

import "reflect"

type S int

func (s S) M() { println("S.M") }

type I interface{ M() }

//
//   The value returned by this operation is guaranteed to be influenced by all
//   the writes on which this operation depends directly or indirectly, and to
//   not be influenced by any of the writes which depend directly or indirectly
//   on this operation.
Status ReadVariableOp(AbstractContext* ctx,
                      AbstractTensorHandle* const resource,