JavaPeerInfo.cs

using System;
using System.Collections.Generic;

namespace Microsoft.Android.Sdk.TrimmableTypeMap;

/// <summary>
/// Represents a Java peer type discovered during assembly scanning.
/// Contains all data needed by downstream generators (TypeMap IL, UCO wrappers, JCW Java sources).
/// Generators consume this data model — they never touch PEReader/MetadataReader.
/// </summary>
public sealed record JavaPeerInfo
{
	/// <summary>
	/// JNI type name, e.g., "android/app/Activity".
	/// Extracted from the [Register] attribute or auto-computed during scanning.
	/// Manifest rooting may later promote this to <see cref="CompatJniName"/> when
	/// a component is referenced by its managed-namespace form.
	/// </summary>
	public required string JavaName { get; set; }

	/// <summary>
	/// Compat JNI type name, e.g., "myapp.namespace/MyType" for user types (uses raw namespace, not CRC64).
	/// For MCW binding types (with [Register]), this equals <see cref="JavaName"/>.
	/// Used by acw-map.txt to support legacy custom view name resolution in layout XMLs.
	/// </summary>
	public required string CompatJniName { get; init; }

	/// <summary>
	/// Full managed type name, e.g., "Android.App.Activity".
	/// </summary>
	public required string ManagedTypeName { get; init; }

	/// <summary>
	/// Managed type namespace, e.g., "Android.App".
	/// </summary>
	public required string ManagedTypeNamespace { get; init; }

	/// <summary>
	/// Managed type short name (without namespace), e.g., "Activity".
	/// </summary>
	public required string ManagedTypeShortName { get; init; }

	/// <summary>
	/// Assembly name the type belongs to, e.g., "Mono.Android".
	/// </summary>
	public required string AssemblyName { get; init; }

	/// <summary>
	/// JNI name of the base Java type, e.g., "android/app/Activity" for a type
	/// that extends Activity. Null for java/lang/Object or types without a Java base.
	/// Needed by JCW Java source generation ("extends" clause).
	/// </summary>
	public string? BaseJavaName { get; set; }

	/// <summary>
	/// JNI names of Java interfaces this type implements, e.g., ["android/view/View$OnClickListener"].
	/// Needed by JCW Java source generation ("implements" clause).
	/// </summary>
	public IReadOnlyList<string> ImplementedInterfaceJavaNames { get; init; } = Array.Empty<string> ();

	public bool IsInterface { get; init; }
	public bool IsAbstract { get; init; }

	/// <summary>
	/// If true, this is a Managed Callable Wrapper (MCW) binding type.
	/// No JCW or RegisterNatives will be generated for it.
	/// </summary>
	public bool DoNotGenerateAcw { get; init; }

	/// <summary>
	/// Types with component attributes ([Activity], [Service], etc.),
	/// custom views from layout XML, or manifest-declared components
	/// are unconditionally preserved (not trimmable).
	/// May be set to <c>true</c> after scanning when the manifest references a type
	/// that the scanner did not mark as unconditional. Should only ever be set
	/// to <c>true</c>, never back to <c>false</c>.
	/// </summary>
	public bool IsUnconditional { get; set; }

	/// <summary>
	/// True for Application and Instrumentation types, plus any generated managed
	/// base classes they rely on during startup. These types cannot call
	/// <c>registerNatives</c> in their static initializer because the native library
	/// (<c>libmonodroid.so</c>) is not loaded until after the Application class is instantiated.
	/// Registration is deferred to <c>ApplicationRegistration.registerApplications()</c>.
	/// This may also be set after scanning when a type is only discovered from
	/// manifest <c>android:name</c> usage on <c>&lt;application&gt;</c> or
	/// <c>&lt;instrumentation&gt;</c>.
	/// </summary>
	public bool CannotRegisterInStaticConstructor { get; set; }

	/// <summary>
	/// Marshal methods: methods with [Register(name, sig, connector)], [Export], or
	/// constructor registrations ([Register(".ctor", sig, "")] / [JniConstructorSignature]).
	/// Constructors are identified by <see cref="MarshalMethodInfo.IsConstructor"/>.
	/// Ordered — the index in this list is the method's ordinal for RegisterNatives.
	/// </summary>
	public IReadOnlyList<MarshalMethodInfo> MarshalMethods { get; init; } = Array.Empty<MarshalMethodInfo> ();

	/// <summary>
	/// Java constructors to emit in the JCW .java file.
	/// Each has a JNI signature and an ordinal index for the nctor_N native method.
	/// </summary>
	public IReadOnlyList<JavaConstructorInfo> JavaConstructors { get; init; } = [];

	/// <summary>
	/// Java fields from [ExportField] attributes.
	/// Each field is initialized by calling the annotated method.
	/// </summary>
	public IReadOnlyList<JavaFieldInfo> JavaFields { get; init; } = [];

	/// <summary>
	/// Information about the activation constructor for this type.
	/// May reference a base type's constructor if the type doesn't define its own.
	/// </summary>
	public ActivationCtorInfo? ActivationCtor { get; init; }

	/// <summary>
	/// For interfaces and abstract types, the name of the invoker type
	/// used to instantiate instances from Java.
	/// </summary>
	public string? InvokerTypeName { get; init; }

	/// <summary>
	/// True if this is an open generic type definition.
	/// Generic types get TypeMap entries but CreateInstance throws NotSupportedException.
	/// </summary>
	public bool IsGenericDefinition { get; init; }

	/// <summary>
	/// Android component attribute data ([Activity], [Service], [BroadcastReceiver], [ContentProvider],
	/// [Application], [Instrumentation]) if present on this type. Used for manifest generation.
	/// </summary>
	public ComponentInfo? ComponentAttribute { get; init; }
}

/// <summary>
/// Describes a marshal method (a method with [Register] or [Export]) on a Java peer type.
/// Contains all data needed to generate a UCO wrapper, a JCW native declaration,
/// and a RegisterNatives call.
/// </summary>
public sealed record MarshalMethodInfo
{
	/// <summary>
	/// JNI method name, e.g., "onCreate".
	/// This is the Java method name (without n_ prefix).
	/// </summary>
	public required string JniName { get; init; }

	/// <summary>
	/// JNI method signature, e.g., "(Landroid/os/Bundle;)V".
	/// Contains both parameter types and return type.
	/// </summary>
	public required string JniSignature { get; init; }

	/// <summary>
	/// The connector string from [Register], e.g., "GetOnCreate_Landroid_os_Bundle_Handler".
	/// Null for [Export] methods.
	/// </summary>
	public string? Connector { get; init; }

	/// <summary>
	/// Name of the managed method this maps to, e.g., "OnCreate".
	/// </summary>
	public required string ManagedMethodName { get; init; }

	/// <summary>
	/// Full name of the type that declares the managed method (may be a base type).
	/// Empty when the declaring type is the same as the peer type.
	/// </summary>
	public string DeclaringTypeName { get; init; } = "";

	/// <summary>
	/// Assembly name of the type that declares the managed method.
	/// Needed for cross-assembly UCO wrapper generation.
	/// Empty when the declaring type is the same as the peer type.
	/// </summary>
	public string DeclaringAssemblyName { get; init; } = "";

	/// <summary>
	/// The native callback method name, e.g., "n_onCreate".
	/// This is the actual method the UCO wrapper delegates to.
	/// </summary>
	public required string NativeCallbackName { get; init; }

	/// <summary>
	/// True if this is a constructor registration.
	/// </summary>
	public bool IsConstructor { get; init; }

	/// <summary>
	/// True if this method comes from an [Export] attribute (rather than [Register]).
	/// [Export] methods use the C# method's access modifier in the JCW Java file
	/// instead of always being "public".
	/// </summary>
	public bool IsExport { get; init; }

	/// <summary>
	/// Java access modifier for [Export] methods ("public", "protected", "private").
	/// Null for [Register] methods (always "public").
	/// </summary>
	public string? JavaAccess { get; init; }

	/// <summary>
	/// For [Export] methods: Java exception types that the method declares it can throw.
	/// Null for [Register] methods.
	/// </summary>
	public IReadOnlyList<string>? ThrownNames { get; init; }

	/// <summary>
	/// For [Export] methods: super constructor arguments string.
	/// Null for [Register] methods.
	/// </summary>
	public string? SuperArgumentsString { get; init; }

	/// <summary>
	/// True if this method was collected from an implemented interface
	/// (Pass 4: CollectInterfaceMethodImplementations), not from the type itself.
	/// </summary>
	public bool IsInterfaceImplementation { get; init; }
}

/// <summary>
/// Describes a JNI parameter for UCO method generation.
/// </summary>
public sealed record JniParameterInfo
{
	/// <summary>
	/// JNI type descriptor, e.g., "Landroid/os/Bundle;", "I", "Z".
	/// </summary>
	public required string JniType { get; init; }

	/// <summary>
	/// Managed parameter type name, e.g., "Android.OS.Bundle", "System.Int32".
	/// </summary>
	public string ManagedType { get; init; } = "";
}

/// <summary>
/// Describes a Java constructor to emit in the JCW .java source file.
/// </summary>
public sealed record JavaConstructorInfo
{
	/// <summary>
	/// JNI constructor signature, e.g., "(Landroid/content/Context;)V".
	/// </summary>
	public required string JniSignature { get; init; }

	/// <summary>
	/// Ordinal index for the native constructor method (nctor_0, nctor_1, ...).
	/// </summary>
	public required int ConstructorIndex { get; init; }

	/// <summary>
	/// For [Export] constructors: super constructor arguments string.
	/// Null for [Register] constructors.
	/// </summary>
	public string? SuperArgumentsString { get; init; }
}

/// <summary>
/// Describes a Java field from an [ExportField] attribute.
/// The field is initialized by calling the annotated method.
/// </summary>
public sealed record JavaFieldInfo
{
	/// <summary>
	/// Java field name, e.g., "STATIC_INSTANCE".
	/// </summary>
	public required string FieldName { get; init; }

	/// <summary>
	/// Java type name for the field, e.g., "java.lang.String".
	/// </summary>
	public required string JavaTypeName { get; init; }

	/// <summary>
	/// Name of the method that initializes this field, e.g., "GetInstance".
	/// </summary>
	public required string InitializerMethodName { get; init; }

	/// <summary>
	/// Java access modifier ("public", "protected", "private").
	/// </summary>
	public required string Visibility { get; init; }

	/// <summary>
	/// Whether the field is static.
	/// </summary>
	public bool IsStatic { get; init; }
}

/// <summary>
/// Describes how to call the activation constructor for a Java peer type.
/// </summary>
public sealed record ActivationCtorInfo
{
	/// <summary>
	/// The type that declares the activation constructor.
	/// May be the type itself or a base type.
	/// </summary>
	public required string DeclaringTypeName { get; init; }

	/// <summary>
	/// The assembly containing the declaring type.
	/// </summary>
	public required string DeclaringAssemblyName { get; init; }

	/// <summary>
	/// The style of activation constructor found.
	/// </summary>
	public required ActivationCtorStyle Style { get; init; }
}

public enum ActivationCtorStyle
{
	/// <summary>
	/// Xamarin.Android style: (IntPtr handle, JniHandleOwnership transfer)
	/// </summary>
	XamarinAndroid,

	/// <summary>
	/// Java.Interop style: (ref JniObjectReference reference, JniObjectReferenceOptions options)
	/// </summary>
	JavaInterop,
}