if (parts != null) {
                    if (summary != null) comma()
                    property("parts") {
                        jsonObjectList(parts) { (isInternal, text) ->
                            property(if (isInternal) "internalText" else "text", text)
                        }
                    }
                }
            }
        }
    }

    private

            }
            current = current.getSuperclass()
        }

        for (int i = classesContainingMethod.size() - 1; i > 0; --i) {
            current = classesContainingMethod.get(i)
            if (!isInternal(current)) {
                // there's another public super class which contains target method
                // it would be reported somewhere else
                return false
            }
        }

        return c.interfaces.any { it.name == interf.name }
    }

    private boolean addedInterfaceIsIncubatingOrInternal(CtClass interf, CtClass c) {
        return (isIncubating(interf) && !isIncubating(c)) || isInternal(interf)
    }

    private boolean isIncubating(CtClass c) {
        return c.annotations.any { it.annotationType().name == 'org.gradle.api.Incubating' }
    }

        this.internal = internal;
    }

    public String getName() {
        return name;
    }

    public ModelType<T> getType() {
        return type;
    }

    public boolean isInternal() {
        return internal;
    }

    public boolean isWritable() {
        return writable;
    }

    public boolean isDeclaredAsHavingUnmanagedType() {
        return declaredAsHavingUnmanagedType;

  args.tuple().emplace_back(TaggedValue(x));
  args.tuple().emplace_back(TaggedValue(x));
  StatusOr<TaggedValue> v = tf_function.Execute(ctx_.get(), args);
  ASSERT_TRUE(tensorflow::errors::IsInternal(v.status())) << v.status();
  ASSERT_TRUE(
      absl::StrContains(v.status().message(), "Shape and dtype of tensor"));
  ASSERT_TRUE(absl::StrContains(v.status().message(),

}

func ldhostobj(ld func(*Link, *bio.Reader, string, int64, string), headType objabi.HeadType, f *bio.Reader, pkg string, length int64, pn string, file string) *Hostobj {
	isinternal := false
	for _, intpkg := range internalpkg {
		if pkg == intpkg {
			isinternal = true
			break
		}
	}

	// DragonFly declares errno with __thread, which results in a symbol

	// Check latency...
	if opts.Threshold > 0 && trcInfo.Duration < opts.Threshold {
		return false
	}

	// Check internal path
	isInternal := isHTTP && HasPrefix(trcInfo.HTTP.ReqInfo.Path, minioReservedBucketPath+SlashSeparator)
	if isInternal && !opts.Internal {
		return false
	}

	// Filter non-errors.
	if isHTTP && opts.OnlyErrors && trcInfo.HTTP.RespInfo.StatusCode < http.StatusBadRequest {