func PodRedirectionActive(pod *corev1.Pod) bool {
	return pod.GetAnnotations()[annotation.AmbientRedirection.Name] == constants.AmbientRedirectionEnabled
}

func podHasSidecar(pod *corev1.Pod) bool {
	if _, f := pod.GetAnnotations()[annotation.SidecarStatus.Name]; f {
		return true
	}
	return false
}

func IsZtunnelPod(systemNs string, pod *corev1.Pod) bool {

            || containsNullable(invokable.getAnnotatedReturnType().getAnnotations());
        // TODO(cpovirk): Should we also check isNullableTypeVariable?
      }

      @Override
      boolean isNullable(Parameter param) {
        return FROM_DECLARATION_ANNOTATIONS_ONLY.isNullable(param)
            || containsNullable(param.getAnnotatedType().getAnnotations())
            || isNullableTypeVariable(param.getAnnotatedType().getType());

}

// InAmbient returns true if a resource is in ambient data plane mode.
func InAmbient(obj metav1.Object) bool {
	if obj == nil {
		return false
	}
	switch t := obj.(type) {
	case *corev1.Pod:
		return t.GetAnnotations()[annotation.AmbientRedirection.Name] == constants.AmbientRedirectionEnabled
	case *corev1.Namespace:
		if t.GetLabels()["istio-injection"] == "enabled" {
			return false
		}

            });
        });
    }

    private void findAnnotations(NodeWithAnnotations<?> node, AbstractLanguageElement currentElement) {
        for (AnnotationExpr child : node.getAnnotations()) {
            if (child instanceof SingleMemberAnnotationExpr && child.getNameAsString().endsWith("ReplacedBy")) {

	}
	return retval
}

func extractRevisionFromPod(pod *corev1.Pod) string {
	return describe.GetRevisionFromPodAnnotation(pod.GetAnnotations())
}

func injectionDisabled(pod *corev1.Pod) bool {
	inject := pod.ObjectMeta.GetAnnotations()[annotation.SidecarInject.Name]
	if lbl, labelPresent := pod.ObjectMeta.GetLabels()[label.SidecarInject.Name]; labelPresent {
		inject = lbl
	}

    FROM_DECLARATION_ANNOTATIONS_ONLY {
      @Override
      boolean isNullable(Invokable<?, ?> invokable) {
        return containsNullable(invokable.getAnnotations());
      }

      @Override
      boolean isNullable(Parameter param) {
        return containsNullable(param.getAnnotations());
      }
    };

    abstract boolean isNullable(Invokable<?, ?> invokable);

    abstract boolean isNullable(Parameter param);

			Name:              un.GetName(),
			Namespace:         un.GetNamespace(),
			Domain:            domain,
			Labels:            un.GetLabels(),
			Annotations:       un.GetAnnotations(),
			ResourceVersion:   un.GetResourceVersion(),
			CreationTimestamp: un.GetCreationTimestamp().Time,
		},
		Spec: data,
	}, nil
}

    ImmutableList<Parameter> parameters = delegate.getParameters();
    assertEquals(1, parameters.size());
    assertEquals(new TypeToken<Iterable<String>>() {}, parameters.get(0).getType());
    assertThat(parameters.get(0).getAnnotations()).isEmpty();
    new EqualsTester().addEqualityGroup(parameters.get(0)).testEquals();
  }

  public void testInstanceMethod_call() throws Exception {

    ImmutableList<Parameter> parameters = delegate.getParameters();
    assertEquals(1, parameters.size());
    assertEquals(new TypeToken<Iterable<String>>() {}, parameters.get(0).getType());
    assertThat(parameters.get(0).getAnnotations()).isEmpty();
    new EqualsTester().addEqualityGroup(parameters.get(0)).testEquals();
  }

  public void testInstanceMethod_call() throws Exception {