virtual void SetStepId(int64_t step_id) = 0;

  // For LLVM style RTTI.
  static bool classof(const AbstractOperation* ptr) {
    return ptr->getKind() == kEager || ptr->getKind() == kTfrt;
  }

 protected:
  explicit ImmediateExecutionOperation(AbstractOperationKind kind)
      : AbstractOperation(kind) {}
  ~ImmediateExecutionOperation() override {}
};

	c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.link()

	pc := gp.sigpc

	if shouldPushSigpanic(gp, pc, uintptr(c.link())) {
		// Make it look the like faulting PC called sigpanic.
		c.set_link(uint64(pc))
	}

	// In case we are panicking from external C code
	sigpanicPC := uint64(abi.FuncPCABIInternal(sigpanic))
	c.set_r28(sigpanicPC >> 32 << 32) // RSB register
	c.set_r30(uint64(uintptr(unsafe.Pointer(gp))))

    @VisibleForTesting
    void buildProblem(Diagnostic<? extends JavaFileObject> diagnostic, ProblemSpec spec) {
        spec.id(mapKindToId(diagnostic.getKind()), mapKindToLabel(diagnostic.getKind()), GradleCoreProblemGroup.compilation().java());
        spec.severity(mapKindToSeverity(diagnostic.getKind()));
        addFormattedMessage(spec, diagnostic);
        addDetails(spec, diagnostic);
        addLocations(spec, diagnostic);
    }

    public void setPath(String path) {
        this.path = path;
    }

    @Override
    public String getKind() {
        return "output";
    }

    @Override
    public void appendNode(Node node) {
        Map<String, Object> attributes = new LinkedHashMap<>();
        attributes.put("kind", getKind());
        attributes.put("path", path);
        node.appendNode("classpathentry", attributes);
    }

        public String getCallableName() {
            return callableName;
        }

        public String getCallerClassName() {
            return callerClassName;
        }

        public CallKind getKind() {
            return kind;
        }

        public boolean isMatchedAtDispatchSite() {
            return isMatchedAtDispatchSite;
        }

        public void markedAsMatchedAtDispatchSite() {

 */

package org.gradle.internal.instrumentation.model;

import org.objectweb.asm.Type;

public interface ParameterInfo {
    String getName();
    Type getParameterType();
    ParameterKindInfo getKind();

 * limitations under the License.
 */

package org.gradle.internal.instrumentation.model;

import java.util.List;

public interface CallableInfo {
    CallableKindInfo getKind();
    CallableOwnerInfo getOwner();
    String getCallableName();
    CallableReturnTypeInfo getReturnType();
    List<ParameterInfo> getParameters();

  virtual Status SummarizeValue(std::string& summary) const;

  // For LLVM style RTTI.
  static bool classof(const AbstractTensorHandle* ptr) {
    return ptr->getKind() == kEager || ptr->getKind() == kTfrt;
  }

 protected:
  explicit ImmediateExecutionTensorHandle(AbstractTensorHandleKind kind)
      : AbstractTensorHandle(kind) {}
  ~ImmediateExecutionTensorHandle() override {}
};

 */
package org.gradle.plugins.ide.eclipse.model;

import groovy.util.Node;

/**
 * Represents an entry in the Eclipse classpath.
 */
public interface ClasspathEntry {
    String getKind();
    void appendNode(Node node);

		items = append(items, usList.Items...)
	}
	kindNameMap := make(map[string][]string)
	for _, o := range items {
		nameList := kindNameMap[o.GetKind()]
		if nameList == nil {
			kindNameMap[o.GetKind()] = []string{}
		}
		kindNameMap[o.GetKind()] = append(kindNameMap[o.GetKind()], o.GetName())
	}
	if len(kindNameMap) == 0 {
		return "", ""
	}
	output, gwlist := "", []string{}
	for kind, name := range kindNameMap {