static MethodDefinition GetMethod(ObjCMethodDecl decl)
{
MethodDefinition md;
methods.TryGetValue(decl.GetName(), out md);
return(md);
}
void Visit(ObjCMethodDecl decl)
{
// don't process methods (or types) that are unavailable for the current platform
if (!decl.IsAvailable() || !(decl.DeclContext as Decl).IsAvailable())
{
return;
}
var method = GetMethod(decl);
if (method == null)
{
return;
}
var framework = Helpers.GetFramework(decl);
if (framework == null)
{
return;
}
if (!decl.HasAttr <ObjCRequiresSuperAttr> ())
{
if (method.RequiresSuper())
{
Log.On(framework).Add($"!extra-requires-super! {method.GetName ()} is incorrectly decorated with an [RequiresSuper] attribute");
}
}
else if (!method.RequiresSuper())
{
Log.On(framework).Add($"!missing-requires-super! {method.GetName ()} is missing an [RequiresSuper] attribute");
}
}
public static string GetName(this ObjCMethodDecl self)
{
if (self == null)
{
return(null);
}
var sb = new StringBuilder();
if (self.IsClassMethod)
{
sb.Append('+');
}
if (self.DeclContext is ObjCCategoryDecl category)
{
sb.Append(category.ClassInterface.Name);
}
else
{
sb.Append((self.DeclContext as NamedDecl).Name);
}
sb.Append("::");
var sel = self.Selector.ToString();
sb.Append(string.IsNullOrEmpty(sel) ? self.Name : sel);
return(sb.ToString());
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind == VisitKind.Enter && AttributeHelpers.FindObjcDeprecated(decl.Attrs, out VersionTuple version))
{
ObjCDeprecatedSelectors[decl.QualifiedName] = version;
}
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind != VisitKind.Enter)
{
return;
}
// protocol members are checked in ObjCProtocolCheck
if (decl.DeclContext is ObjCProtocolDecl)
{
return;
}
// don't process methods (or types) that are unavailable for the current platform
if (!decl.IsAvailable() || !(decl.DeclContext as Decl).IsAvailable())
{
return;
}
var framework = Helpers.GetFramework(decl);
if (framework == null)
{
return;
}
string selector = decl.GetSelector();
if (String.IsNullOrEmpty(selector))
{
return;
}
var name = (decl.IsClassMethod ? "+" : String.Empty) + decl.QualifiedName;
bool found = qualified_selectors.Contains(name);
if (!found)
{
// a category could be inlined into the type it extend
var category = decl.DeclContext as ObjCCategoryDecl;
if (category != null)
{
var cname = category.Name;
if (cname == null)
{
name = GetCategoryBase(category) + name;
}
else
{
name = name.ReplaceFirstInstance(cname, GetCategoryBase(category));
}
found = qualified_selectors.Contains(name);
}
}
if (!found)
{
Log.On(framework).Add($"!missing-selector! {name} not bound");
}
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind != VisitKind.Enter)
{
return;
}
Visit(decl);
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind == VisitKind.Enter && AttributeHelpers.FindObjcDeprecated(decl.Attrs, out VersionTuple version))
{
var qn = decl.QualifiedName;
if (decl.IsClassMethod)
{
qn = "+" + qn;
}
ObjCDeprecatedSelectors [qn] = version;
}
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind != VisitKind.Enter)
{
return;
}
// don't process methods (or types) that are unavailable for the current platform
if (!decl.IsAvailable() || !(decl.DeclContext as Decl).IsAvailable())
{
return;
}
var method = GetMethod(decl);
// don't report missing [DesignatedInitializer] for types that are not bound - that's a different problem
if (method == null)
{
return;
}
var framework = Helpers.GetFramework(decl);
if (framework == null)
{
return;
}
var designated_initializer = method.IsDesignatedInitializer();
if (!method.IsConstructor)
{
if (designated_initializer)
{
Log.On(framework).Add($"!incorrect-designated-initializer! {method.GetName ()} is not a constructor");
}
}
else if (decl.IsDesignatedInitializer)
{
if (!designated_initializer)
{
Log.On(framework).Add($"!missing-designated-initializer! {method.GetName ()} is missing an [DesignatedInitializer] attribute");
}
}
else
{
if (designated_initializer)
{
Log.On(framework).Add($"!extra-designated-initializer! {method.GetName ()} is incorrectly decorated with an [DesignatedInitializer] attribute");
}
}
}
static string GetName(ObjCProtocolDecl decl, ObjCMethodDecl method)
{
var sb = new StringBuilder();
if (method.IsClassMethod)
{
sb.Append('+');
}
sb.Append(decl.Name);
sb.Append("::");
sb.Append(GetSelector(method));
return(sb.ToString());
}
static string GetSelector(ObjCMethodDecl method)
{
var result = method.Selector.ToString();
if (result != null)
{
return(result);
}
if (method.IsPropertyAccessor || (method.DeclContext is ObjCProtocolDecl))
{
return(method.Name);
}
return(null);
}
bool ContainsSimdTypes(ObjCMethodDecl decl, ref string simd_type, ref bool requires_marshal_directive)
{
if (IsSimdType(decl, decl.ReturnQualType, ref simd_type, ref requires_marshal_directive))
{
return(true);
}
var is_simd_type = false;
foreach (var param in decl.Parameters)
{
is_simd_type |= IsSimdType(decl, param.QualType, ref simd_type, ref requires_marshal_directive);
}
return(is_simd_type);
}
public static string GetName(this ObjCMethodDecl self)
{
if (self == null)
{
return(null);
}
var sb = new StringBuilder();
if (self.IsClassMethod)
{
sb.Append('+');
}
sb.Append((self.DeclContext as NamedDecl).Name);
sb.Append("::");
sb.Append(self.Selector);
return(sb.ToString());
}
void VisitObjCMethodDecl(ObjCMethodDecl decl)
{
var framework = Helpers.GetFramework(decl);
if (framework == null)
{
return;
}
var method = GetMethod(decl);
if (method == null)
{
return;
}
var dt = method.DeclaringType;
if (dt.HasNestedTypes)
{
foreach (var nt in dt.NestedTypes)
{
if (nt.Name != dt.Name + "Appearance")
{
continue;
}
// find matching method, including parameters (we have overloads)
var fn = method.FullName;
int ms = fn.IndexOf("::");
fn = fn.Insert(ms, $"/{dt.Name}Appearance");
foreach (var m in nt.Methods)
{
if (m.FullName != fn)
{
continue;
}
appearance_methods.Add(m); // legit one
return;
}
}
}
Log.On(framework).Add($"!missing-ui-appearance-support! {method.GetName ()} is missing [Appearance]");
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind != VisitKind.Enter)
{
return;
}
// don't process methods (or types) that are unavailable for the current platform
if (!decl.IsAvailable() || !(decl.DeclContext as Decl).IsAvailable())
{
return;
}
// does not look exposed, but part of the dump
if (decl.DumpToString().IndexOf("UI_APPEARANCE_SELECTOR", StringComparison.OrdinalIgnoreCase) < 0)
{
return;
}
VisitObjCMethodDecl(decl);
}
public static string GetSelector(this ObjCMethodDecl self)
{
return(self.Selector.ToString() ?? self.Name);
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind != VisitKind.Enter)
{
return;
}
// don't process methods (or types) that are unavailable for the current platform
if (!decl.IsAvailable() || !(decl.DeclContext as Decl).IsAvailable())
{
return;
}
var framework = Helpers.GetFramework(decl);
if (framework == null)
{
return;
}
var simd_type = string.Empty;
var requires_marshal_directive = false;
var native_simd = ContainsSimdTypes(decl, ref simd_type, ref requires_marshal_directive);
ManagedSimdInfo info;
managed_methods.TryGetValue(decl.GetName(), out info);
var method = info?.Method;
if (!native_simd)
{
if (method != null)
{
// The managed method uses types that were incorrectly used in place of the correct Simd types,
// but the native method doesn't use the native Simd types. This means the binding is correct.
}
else
{
// Neither the managed nor the native method have anything to do with Simd types.
}
return;
}
if (method == null)
{
// Could not map the native method to a managed method.
// This needs investigation, to see why the native method couldn't be mapped.
// Check if this is new API, in which case it probably couldn't be mapped because we haven't bound it.
var is_new = false;
var attrs = decl.Attrs.ToList();
var parentClass = decl.DeclContext as Decl;
if (parentClass != null)
{
attrs.AddRange(parentClass.Attrs);
}
foreach (var attr in attrs)
{
var av_attr = attr as AvailabilityAttr;
if (av_attr == null)
{
continue;
}
if (av_attr.Platform.Name != "ios")
{
continue;
}
if (av_attr.Introduced.Major >= 11)
{
is_new = true;
break;
}
}
if (is_new && !very_strict)
{
return;
}
if (!strict)
{
return;
}
Log.On(framework).Add($"!missing-simd-managed-method! {decl}: could not find a managed method for the native method {decl.GetName ()} (selector: {decl.Selector}). Found the simd type '{simd_type}' in the native signature.");
return;
}
if (!info.ContainsInvalidMappingForSimd)
{
// The managed method does not have any types that are incorrect for Simd.
if (requires_marshal_directive)
{
CheckMarshalDirective(method, simd_type);
}
return;
}
if (method.IsObsolete())
{
// We have a potentially broken managed method, but it's obsolete. That's fine.
return;
}
if (requires_marshal_directive)
{
CheckMarshalDirective(method, simd_type);
}
// We have a potentially broken managed method. This needs fixing/investigation.
Log.On(framework).Add($"!unknown-simd-type-in-signature! {method}: the native signature has a simd type ({simd_type}), while the corresponding managed method is using an incorrect (non-simd) type.");
}
public static string GetSelector(this ObjCMethodDecl self)
{
return(self.Selector.ToString() ?? (self.IsPropertyAccessor ? self.Name : null));
}
public override void VisitObjCMethodDecl(ObjCMethodDecl decl, VisitKind visitKind)
{
if (visitKind != VisitKind.Enter)
{
return;
}
// don't process methods (or types) that are unavailable for the current platform
if (!decl.IsAvailable() || !(decl.DeclContext as Decl).IsAvailable())
{
return;
}
var method = GetMethod(decl);
// don't report missing nullability on types that are not bound - that's a different problem
if (method == null)
{
return;
}
var framework = Helpers.GetFramework(decl);
if (framework == null)
{
return;
}
var t = method.DeclaringType;
// look for [NullableContext] for defaults
var managed_default_nullability = GetNullableContext(method);
if (managed_default_nullability == Null.Oblivious)
{
managed_default_nullability = GetNullableContext(t);
}
// check parameters
// categories have an offset of 1 for the extension method type (spotted as static types)
int i = t.IsSealed && t.IsAbstract ? 1 : 0;
foreach (var p in decl.Parameters)
{
var mp = method.Parameters [i++];
// a managed `out` value does not need to be inialized, won't be null (but can be ignored)
if (mp.IsOut)
{
continue;
}
var pt = mp.ParameterType;
// if bound as `IntPtr` then nullability attributes won't be present
if (pt.IsValueType)
{
continue;
}
Null parameter_nullable;
// if we used a type by reference (e.g. `ref float foo`); or a nullable type (e.g. `[BindAs]`)
// then assume it's meant as a nullable type) without additional decorations
if (pt.IsByReference || pt.FullName.StartsWith("System.Nullable`1<", StringComparison.Ordinal))
{
parameter_nullable = Null.Annotated;
}
else
{
// check C# 8 compiler attributes
var nullable = GetNullable(mp);
if (nullable.Length > 1)
{
// check the type itself, TODO check the generics (don't think we have such cases yet)
parameter_nullable = nullable [0];
}
else if (nullable.Length == 0)
{
parameter_nullable = managed_default_nullability;
}
else
{
parameter_nullable = nullable [0];
}
}
// match with native and, if needed, report discrepancies
p.QualType.Type.GetNullability(p.AstContext, out var nullability);
switch (nullability)
{
case NullabilityKind.NonNull:
if (parameter_nullable == Null.Annotated)
{
Log.On(framework).Add($"!extra-null-allowed! '{method.FullName}' has a extraneous [NullAllowed] on parameter #{i-1}");
}
break;
case NullabilityKind.Nullable:
if (parameter_nullable != Null.Annotated)
{
Log.On(framework).Add($"!missing-null-allowed! '{method.FullName}' is missing an [NullAllowed] on parameter #{i-1}");
}
break;
case NullabilityKind.Unspecified:
break;
}
}
// with .net a constructor will always return something (or throw)
// that's not the case in ObjC where `init*` can return `nil`
if (method.IsConstructor)
{
return;
}
var mrt = method.ReturnType;
// if bound as an `IntPtr` then the nullability will not be visible in the metadata
if (mrt.IsValueType)
{
return;
}
Null return_nullable;
// if we used a nullable type (e.g. [BindAs] then assume it's meant as a nullable type) without additional decorations
if (mrt.FullName.StartsWith("System.Nullable`1<", StringComparison.Ordinal))
{
return_nullable = Null.Annotated;
}
else
{
ICustomAttributeProvider cap;
// the managed attributes are on the property, not the special methods
if (method.IsGetter)
{
var property = method.FindProperty();
// also `null_resettable` will only show something (natively) on the setter (since it does not return null, but accept it)
// in this case we'll trust xtro checking the setter only (if it exists, if not then it can't be `null_resettable`)
if (property.SetMethod != null)
{
return;
}
cap = property;
}
else
{
cap = method.MethodReturnType;
}
Null [] mrt_nullable = GetNullable(cap);
if (mrt_nullable.Length > 1)
{
// check the type itself, TODO check the generics (don't think we have such cases yet)
return_nullable = mrt_nullable [0];
}
else if (mrt_nullable.Length == 0)
{
return_nullable = managed_default_nullability;
}
else
{
return_nullable = mrt_nullable [0];
}
}
var rt = decl.ReturnQualType;
rt.Type.GetNullability(decl.AstContext, out var rnull);
switch (rnull)
{
case NullabilityKind.NonNull:
if (return_nullable == Null.Annotated)
{
Log.On(framework).Add($"!extra-null-allowed! '{method}' has a extraneous [NullAllowed] on return type");
}
break;
case NullabilityKind.Nullable:
if (return_nullable != Null.Annotated)
{
Log.On(framework).Add($"!missing-null-allowed! '{method}' is missing an [NullAllowed] on return type");
}
break;
case NullabilityKind.Unspecified:
break;
}
}
