/// <summary>
/// returns instance of <see cref="HowToGuard"/> for <see cref="ISymbol"/>
/// </summary>
/// <param name="target">instance of <see cref="ISymbol"/></param>
/// <returns>instance of <see cref="HowToGuard"/></returns>
public static HowToGuard GetGuardForSymbol(ISymbol target)
{
var plat = Analyzer.GetPlatformForSymbol(target);
switch (plat.Kind)
{
case PlatformKind.ExtensionSDK:
return(new HowToGuard()
{
TypeToCheck = target.Kind == SymbolKind.NamedType ? target.ToDisplayString() : target.ContainingType.ToDisplayString(),
KindOfCheck = "IsTypePresent"
});
case PlatformKind.Uwp:
if (target.Kind == SymbolKind.NamedType)
{
return(new HowToGuard()
{
TypeToCheck = target.ToDisplayString(),
KindOfCheck = "IsTypePresent"
});
}
else
{
var g = new HowToGuard
{
TypeToCheck = target.ContainingType.ToDisplayString()
};
var d0 = Analyzer.GetUniversalApiAdditions(Analyzer.N0DifferencesRes);
var d1 = Analyzer.GetUniversalApiAdditions(Analyzer.N1DifferencesRes);
if (!d0.TryGetValue(g.TypeToCheck, out List <NewMember> newMembers))
{
d1.TryGetValue(g.TypeToCheck, out newMembers);
}
if (newMembers == null)
{
throw new InvalidOperationException("oops! expected this UWP version API to be in the dictionary of new things");
}
g.MemberToCheck = target.Name;
if (target.Kind == SymbolKind.Field)
{
// the only fields in WinRT are enum fields
g.KindOfCheck = "IsEnumNamedValuePresent";
}
else if (target.Kind == SymbolKind.Event)
{
g.KindOfCheck = "IsEventPresent";
}
else if (target.Kind == SymbolKind.Property)
{
// TODO: if SDK starts introducing additional accessors on properties, we'll have to change this
g.KindOfCheck = "IsPropertyPresent";
}
else if (target.Kind == SymbolKind.Method)
{
g.KindOfCheck = "IsMethodPresent";
if (target.Kind == SymbolKind.Method && plat.ByParameterCount)
{
g.ParameterCountToCheck = (target as IMethodSymbol).Parameters.Length;
}
}
return(g);
}
default:
throw new InvalidOperationException("oops! don't know why I was asked to check something that's fine");
}
}
/// <summary>
/// This function tells which version/platform the symbol is from.
/// </summary>
/// <param name="symbol">represents a compiler <see cref="ISymbol"/></param>
/// <returns>instance of <see cref="Platform"/></returns>
public static Platform GetPlatformForSymbol(ISymbol symbol)
{
if (symbol == null)
{
return(new Platform(PlatformKind.Unchecked));
}
if (symbol.ContainingNamespace != null && symbol.ContainingNamespace.ToDisplayString().StartsWith("Windows."))
{
var assembly = symbol.ContainingAssembly.Name;
var version = symbol.ContainingAssembly.Identity.Version.Major;
// Any call to ApiInformation.* is allowed without warning
if (symbol.ContainingType?.Name == "ApiInformation")
{
return(new Platform(PlatformKind.Uwp, Analyzer.N2SDKVersion));
}
// Don't want to give warning when analyzing code in an PCL project.
// In those two targets, every Windows type is found in Windows.winmd, so that's how we'll suppress it:
if (assembly == "Windows")
{
return(new Platform(PlatformKind.Unchecked));
}
// Some WinRT types like Windows.UI.Color get projected to come from .NET assemblies, always present:
if (assembly.StartsWith("System.Runtime."))
{
return(new Platform(PlatformKind.Uwp, Analyzer.N2SDKVersion));
}
// Some things are emphatically part of UWP.10240
if (assembly == "Windows.Foundation.FoundationContract" || (assembly == "Windows.Foundation.UniversalApiContract" && version == 1))
{
return(new Platform(PlatformKind.Uwp, Analyzer.N2SDKVersion));
}
if (assembly == "Windows.Foundation.UniversalApiContract")
{
var isType = symbol.Kind == SymbolKind.NamedType;
var typeName = isType ? symbol.ToDisplayString() : symbol.ContainingType.ToDisplayString();
TypePresenceIndicator presentInN0ApiDiff = CheckCollectionForType(Analyzer.GetUniversalApiAdditions(Analyzer.N0DifferencesRes), typeName, symbol);
if (presentInN0ApiDiff == TypePresenceIndicator.New)
{
// the entire type was found in Target Version
return(new Platform(PlatformKind.Uwp, Analyzer.N0SDKVersion));
}
else if (presentInN0ApiDiff == TypePresenceIndicator.Changes)
{
// the entire type was found in Target Version with matching parameter lengths
return(new Platform(PlatformKind.Uwp, Analyzer.N0SDKVersion, true));
}
else
{
TypePresenceIndicator presentInN1ApiDiff = CheckCollectionForType(Analyzer.GetUniversalApiAdditions(Analyzer.N1DifferencesRes), typeName, symbol);
if (presentInN1ApiDiff == TypePresenceIndicator.New)
{
// the entire type was found in Target Version
return(new Platform(PlatformKind.Uwp, Analyzer.N1SDKVersion));
}
else if (presentInN1ApiDiff == TypePresenceIndicator.Changes)
{
// the entire type was found in Target Version with matching parameter lengths
return(new Platform(PlatformKind.Uwp, Analyzer.N1SDKVersion, true));
}
else
{
// the type was in Min version
return(new Platform(PlatformKind.Uwp, Analyzer.N2SDKVersion));
}
}
}
// All other Windows.* types come from platform-specific extensions
return(new Platform(PlatformKind.ExtensionSDK));
}
else
{
return(new Platform(PlatformKind.Unchecked));
}
}