private bool CheckSubsetNoOrderConstructor(
ConstructorSetting constructorSetting,
IMethodSymbol constructor
)
{
if (constructorSetting.ConstructorArgumentsTypes.Count > constructor.Parameters.Length)
{
return(false);
}
var groups = (
from cat in constructorSetting.ConstructorArgumentsTypes
let catn = cat.ToDisplayString()
group cat by catn into catg
select catg).ToList();
foreach (var group in groups)
{
var needType = group.First();
var needCount = group.Count();
var existsCount = constructor.Parameters
.Where(p => SymbolEqualityComparer.IncludeNullability.Equals(p.Type, needType))
.Count()
;
if (existsCount < needCount)
{
return(false);
}
}
return(true);
}
private bool CheckSubsetAndOrderConstructor(
ConstructorSetting constructorSetting,
IMethodSymbol constructor
)
{
if (constructorSetting.ConstructorArgumentsTypes.Count > constructor.Parameters.Length)
{
return(false);
}
var startIndex = 0;
var ps = constructor.Parameters.ToList();
foreach (var cat in constructorSetting.ConstructorArgumentsTypes)
{
startIndex = ps.FindIndex(startIndex, p => SymbolEqualityComparer.IncludeNullability.Equals(cat, p.Type));
if (startIndex < 0)
{
return(false);
}
startIndex++;
}
return(true);
}
private bool CheckAllAndOrderConstructor(
ConstructorSetting constructorSetting,
IMethodSymbol constructor
)
{
if (constructorSetting.ConstructorArgumentsTypes.Count != constructor.Parameters.Length)
{
return(false);
}
for (var i = 0; i < constructorSetting.ConstructorArgumentsTypes.Count; i++)
{
var need = constructorSetting.ConstructorArgumentsTypes[i];
var exists = constructor.Parameters[i].Type;
if (!SymbolEqualityComparer.IncludeNullability.Equals(exists, need))
{
return(false);
}
}
return(true);
}
private bool CheckConstructor(
ConstructorSetting constructorSetting,
IMethodSymbol constructor
)
{
switch (constructorSetting.CheckMode)
{
case ConstructorSettingsEnum.AllAndOrder:
return(CheckAllAndOrderConstructor(constructorSetting, constructor));
case ConstructorSettingsEnum.SubsetAndOrder:
return(CheckSubsetAndOrderConstructor(constructorSetting, constructor));
case ConstructorSettingsEnum.SubsetNoOrder:
return(CheckSubsetNoOrderConstructor(constructorSetting, constructor));
default:
throw new DpdtException(
DpdtExceptionTypeEnum.ConstructorArgumentMiss,
$@"Unknown constructor settings for {constructor.ContainingType?.ToDisplayString() ?? "<no type>"})"
);
}
}
public BaseParsedBindExpression(
BindScopeEnum scope,
List <Tuple <InvocationExpressionSyntax, IMethodSymbol> > invocationSymbols
)
{
if (invocationSymbols is null)
{
throw new ArgumentNullException(nameof(invocationSymbols));
}
_scope = scope;
var settingScopes = new HashSet <string>();
var setupInvocations = invocationSymbols.FindAll(p => p.Item2.Name == nameof(IConfigureAndConditionalBinding.Setup));
foreach (var setupInvocation in setupInvocations)
{
var settingSymbol = (INamedTypeSymbol)setupInvocation.Item2.TypeArguments.First();
IDefinedSetting setting;
if (settingSymbol.BaseType != null && settingSymbol.BaseType.ToDisplayString() == typeof(AllAndOrderConstructorSetting).FullName)
{
var constructorSetting = new ConstructorSetting(ConstructorSettingsEnum.AllAndOrder);
constructorSetting.AddRange(
settingSymbol.TypeArguments
);
setting = constructorSetting;
}
else if (settingSymbol.BaseType != null && settingSymbol.BaseType.ToDisplayString() == typeof(SubsetAndOrderConstructorSetting).FullName)
{
var constructorSetting = new ConstructorSetting(ConstructorSettingsEnum.SubsetAndOrder);
constructorSetting.AddRange(
settingSymbol.TypeArguments
);
setting = constructorSetting;
}
else if (settingSymbol.BaseType != null && settingSymbol.BaseType.ToDisplayString() == typeof(SubsetNoOrderConstructorSetting).FullName)
{
var constructorSetting = new ConstructorSetting(ConstructorSettingsEnum.SubsetNoOrder);
constructorSetting.AddRange(
settingSymbol.TypeArguments
);
setting = constructorSetting;
}
else if (settingSymbol.ToDisplayString() == typeof(PerformCircularCheck).FullName)
{
setting = new CircularSetting(true);
}
else if (settingSymbol.ToDisplayString() == typeof(SuppressCircularCheck).FullName)
{
setting = new CircularSetting(false);
}
else if (settingSymbol.ToDisplayString() == typeof(AllowedCrossCluster).FullName)
{
setting = new CrossClusterSetting(CrossClusterSettingEnum.AllowedCrossCluster);
}
else if (settingSymbol.ToDisplayString() == typeof(MustBeCrossCluster).FullName)
{
setting = new CrossClusterSetting(CrossClusterSettingEnum.MustBeCrossCluster);
}
else if (settingSymbol.ToDisplayString() == typeof(OnlyLocalCluster).FullName)
{
setting = new CrossClusterSetting(CrossClusterSettingEnum.OnlyLocal);
}
else if (settingSymbol.ToDisplayString() == typeof(NoWrappers).FullName)
{
setting = new WrapperSetting(false);
}
else if (settingSymbol.ToDisplayString() == typeof(ProduceWrappers).FullName)
{
setting = new WrapperSetting(true);
}
else
{
throw new DpdtException(
DpdtExceptionTypeEnum.IncorrectBinding_IncorrectSetting,
$"Incorrect setting used [{settingSymbol.ToGlobalDisplayString()}]",
settingSymbol.ToGlobalDisplayString()
);
}
if (settingScopes.Contains(setting.Scope))
{
throw new DpdtException(
DpdtExceptionTypeEnum.IncorrectBinding_IncorrectSetting,
$"Only one settings of each scope is allowed [{setting.Scope}]",
settingSymbol.ToGlobalDisplayString()
);
}
settingScopes.Add(setting.Scope);
if (!setting.IsAllowedFor(scope))
{
throw new DpdtException(
DpdtExceptionTypeEnum.IncorrectBinding_IncorrectSetting,
$"Setting {setting.GetType().Name} is incompatible with scope {scope}"
);
}
_settings.Add(setting);
}
}
