public static void Load(this IPropertyModel @this, ICodeTextWriter writer, SourceBuilder builder, IPropertySymbol property, ScopeInfo scope, IEnumerable <IMemberInfo> references)
{
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteIdentifier(builder2, property);
@this.Name = builder2.ToString();
}
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteTypeReference(builder2, property.Type, scope);
@this.Type = builder2.ToString();
}
@this.HaveGetter = property.GetMethod != null;
@this.HaveSetter = property.SetMethod != null;
foreach (IMemberInfo reference in references)
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WritePropertyCall(builder2, reference, property, scope, SemanticFacts.IsNullable(writer.Compilation, property.Type), false);
@this.Expressions.Add(builder2.ToString());
}
if (@this is ILocalPropertyExpressionModel this2)
{
this2.Load(writer, builder, property, scope, references);
}
}
private static bool AddSpecialTypeKeyword(TypeSymbol symbol, ArrayBuilder <SymbolDescriptionPart> builder)
{
var specialType = symbol.GetSpecialTypeSafe();
switch (specialType)
{
case SpecialType.System_Void:
case SpecialType.System_SByte:
case SpecialType.System_Int16:
case SpecialType.System_Int32:
case SpecialType.System_Int64:
case SpecialType.System_Byte:
case SpecialType.System_UInt16:
case SpecialType.System_UInt32:
case SpecialType.System_UInt64:
case SpecialType.System_Single:
case SpecialType.System_Double:
case SpecialType.System_Decimal:
case SpecialType.System_Char:
case SpecialType.System_Boolean:
case SpecialType.System_String:
case SpecialType.System_Object:
//not calling AddKeyword because someone else is working out the text for us
builder.Add(new SymbolDescriptionPart
{
Kind = SymbolDescriptionPartKind.Keyword,
Text = SemanticFacts.GetLanguageName(specialType),
});
return(true);
default:
return(false);
}
}
private static void AnalyzeAssignmentStatementIdentifier(
IdentifierNameSyntax identifier,
Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax,
Dictionary <string, IdentifierNameSyntax> firstVarUsageSyntax,
Dictionary <string, IdentifierNameSyntax> firstRecordChangeSyntax,
NavTypeKind variableNavTypeKind)
{
// ISSUE: variable of a compiler-generated type
CodeExpressionSyntax target = ((AssignmentStatementSyntax)identifier.Parent).Target;
if (target.IsKind(SyntaxKind.IdentifierName))
{
SyntaxToken identifier1 = ((SimpleNameSyntax)target).Identifier;
string valueText1 = identifier1.ValueText;
identifier1 = identifier.Identifier;
string valueText2 = identifier1.ValueText;
if (SemanticFacts.IsSameName(valueText1, valueText2))
{
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
return;
}
if (variableNavTypeKind == NavTypeKind.Record)
{
firstRecordChangeSyntax.AddIdentifierIfNotExist((IdentifierNameSyntax)target);
return;
}
}
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
}
private static void AnalyzeArrayIndexExpressionIdentifier(
IdentifierNameSyntax identifier,
Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax)
{
// ISSUE: variable of a compiler-generated type
ElementAccessExpressionSyntax parent = (ElementAccessExpressionSyntax)identifier.Parent;
if (!parent.Parent.IsKind(SyntaxKind.AssignmentStatement))
{
return;
}
switch (((AssignmentStatementSyntax)parent.Parent).Target.Kind)
{
case SyntaxKind.ArrayIndexExpression:
SyntaxToken identifier1 = ((SimpleNameSyntax)((ElementAccessExpressionSyntax)((AssignmentStatementSyntax)parent.Parent).Target).Expression).Identifier;
string valueText1 = identifier1.ValueText;
identifier1 = identifier.Identifier;
string valueText2 = identifier1.ValueText;
if (!SemanticFacts.IsSameName(valueText1, valueText2))
{
break;
}
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
break;
case SyntaxKind.IdentifierName:
if (!SemanticFacts.IsSameName(((SimpleNameSyntax)((AssignmentStatementSyntax)parent.Parent).Target).Identifier.ValueText, identifier.Identifier.ValueText))
{
break;
}
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
break;
}
}
private static void AnalyzeForStatementIdentifier(
IdentifierNameSyntax identifier,
Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax,
Dictionary <string, IdentifierNameSyntax> firstVarUsageSyntax)
{
// ISSUE: variable of a compiler-generated type
IdentifierNameSyntax loopVariable = (IdentifierNameSyntax)((ForStatementSyntax)identifier.Parent).LoopVariable;
SyntaxToken identifier1;
string nameA;
if (loopVariable == null)
{
nameA = (string)null;
}
else
{
identifier1 = loopVariable.Identifier;
nameA = identifier1.ValueText;
}
identifier1 = identifier.Identifier;
string valueText = identifier1.ValueText;
if (SemanticFacts.IsSameName(nameA, valueText))
{
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
}
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
}
public static void Load(this IMethodModel @this, ICodeTextWriter writer, SourceBuilder builder, IMethodSymbol method, ScopeInfo scope, IEnumerable <IMemberInfo> references)
{
var methodScope = new ScopeInfo(scope);
if (method.IsGenericMethod)
{
methodScope.CreateAliases(method.TypeArguments);
}
(bool isAsync, bool methodReturnsValue) = SemanticFacts.IsAsyncAndGetReturnType(writer.Compilation, method);
bool canUseAsync = true;
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteIdentifier(builder2, method);
if (method.IsGenericMethod)
{
builder2.Append('<');
writer.WriteTypeArgumentsCall(builder2, method.TypeArguments, methodScope);
builder2.Append('>');
}
@this.Name = builder2.ToString();
}
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteTypeReference(builder2, method.ReturnType, methodScope);
@this.ReturnType = builder2.ToString();
}
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteParameterDefinition(builder2, methodScope, method.Parameters);
@this.ArgumentsDefinition = builder2.ToString();
}
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WriteCallParameters(builder2, method.Parameters);
@this.CallArguments = builder2.ToString();
}
@this.IsAsync = isAsync && canUseAsync;
@this.ReturnExpected = (isAsync && methodReturnsValue == false) ? canUseAsync == false : methodReturnsValue;
foreach (IMemberInfo reference in references)
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
if (isAsync && canUseAsync)
{
writer.WriteMethodCall(builder2, reference, method, methodScope, false, false, false);
}
else
{
writer.WriteMethodCall(builder2, reference, method, methodScope, false, SemanticFacts.IsNullable(writer.Compilation, method.ReturnType), reference.PreferCoalesce);
}
@this.Expressions.Add(builder2.ToString());
}
}
public bool TryGetSpeculativeSemanticModel(
SemanticModel oldSemanticModel,
SyntaxNode oldNode,
SyntaxNode newNode,
out SemanticModel speculativeModel
) =>
SemanticFacts.TryGetSpeculativeSemanticModel(
oldSemanticModel,
oldNode,
newNode,
out speculativeModel
);
public string GenerateNameForExpression(
SemanticModel semanticModel,
SyntaxNode expression,
bool capitalize,
CancellationToken cancellationToken
) =>
SemanticFacts.GenerateNameForExpression(
semanticModel,
expression,
capitalize,
cancellationToken
);
private static void AnalyzeForEachStatementIdentifier(
IdentifierNameSyntax identifier,
Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax,
Dictionary <string, IdentifierNameSyntax> firstVarUsageSyntax)
{
SyntaxToken identifier1 = ((ForEachStatementSyntax)identifier.Parent).IterationVariable.Identifier;
string valueText1 = identifier1.ValueText;
identifier1 = identifier.Identifier;
string valueText2 = identifier1.ValueText;
(SemanticFacts.IsSameName(valueText1, valueText2) ? firstVarInitializerSyntax : firstVarUsageSyntax).AddIdentifierIfNotExist(identifier);
}
private static void AnalyzeMemberAccessIdentifier(
IdentifierNameSyntax identifier,
Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax,
Dictionary <string, IdentifierNameSyntax> firstVarUsageSyntax,
Dictionary <string, IdentifierNameSyntax> lastRecordModifyInvocationSyntax,
Dictionary <string, IdentifierNameSyntax> firstRecordChangeSyntax,
NavTypeKind variableNavTypeKind)
{
// ISSUE: variable of a compiler-generated type
MemberAccessExpressionSyntax parent = (MemberAccessExpressionSyntax)identifier.Parent;
if (variableNavTypeKind != NavTypeKind.Record)
{
return;
}
string str = string.Empty;
switch (parent.Parent.Kind)
{
case SyntaxKind.ExpressionStatement:
str = ((ExpressionStatementSyntax)parent.Parent).Expression.GetNameStringValue();
break;
case SyntaxKind.InvocationExpression:
str = parent.Name.ToString();
break;
}
if (string.IsNullOrEmpty(str) || SemanticFacts.IsSameName(str, "validate"))
{
firstRecordChangeSyntax.AddIdentifierIfNotExist(identifier);
}
else
{
if (VariableInitializationUsageAnalyzer.changingBuildInMethods.Contains(str))
{
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
}
if (VariableInitializationUsageAnalyzer.initBuildInMethods.Contains(str))
{
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
}
if (!SemanticFacts.IsSameName("modify", str))
{
return;
}
lastRecordModifyInvocationSyntax.AddLastRecordModifyInvocationSyntax(identifier);
}
}
public static void Load(this ILocalPropertyExpressionModel @this, ICodeTextWriter writer, SourceBuilder builder, IPropertySymbol property, ScopeInfo scope, IEnumerable <IMemberInfo> references)
{
foreach (IMemberInfo reference in references)
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WritePropertyCall(builder2, reference, property, scope, SemanticFacts.IsNullable(writer.Compilation, property.Type), reference.PreferCoalesce);
@this.GetExpressions.Add(builder2.ToString());
}
foreach (IMemberInfo reference in references)
{
SourceBuilder builder2 = builder.AppendNewBuilder(false);
writer.WritePropertyCall(builder2, reference, property, scope, false, false);
@this.SetExpressions.Add(builder2.ToString());
}
}
private static void CheckTranslations(
CompilationAnalysisContext compilationAnalysisContext,
NavAppManifest manifest)
{
if (!manifest.CompilerFeatures.ShouldGenerateTranslationFile())
{
return;
}
List <string> stringList = new List <string>();
foreach (string supportedCountry in AppSourceCopConfigurationProvider.GetSupportedCountries(compilationAnalysisContext.Compilation))
{
if (LocalizationHelper.CountryCodeToLanguageCodes.ContainsKey(supportedCountry))
{
stringList.Add(supportedCountry);
}
}
if (stringList.Count == 0 || EmailAndPhoneNoMustNotBePresentInTheSource.GetLanguageCodesForSupportedCountries((IEnumerable <string>)stringList).Count == 0)
{
return;
}
foreach (string xliffLanguageFile in LanguageFileUtilities.GetXliffLanguageFiles(compilationAnalysisContext.Compilation.FileSystem, manifest.AppName))
{
try
{
MemoryStream memoryStream = new MemoryStream(compilationAnalysisContext.Compilation.FileSystem.ReadBytes(xliffLanguageFile));
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load((Stream)memoryStream);
Location propertyLocation = AppSourceCopConfigurationProvider.GetAppSourceCopConfigurationPropertyLocation(compilationAnalysisContext.Compilation, "SupportedCountries");
foreach (XmlNode xmlNode in xmlDocument.GetElementsByTagName("trans-unit", "urn:oasis:names:tc:xliff:document:1.2"))
{
string str = xmlNode.Attributes["id"].Value;
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
if (SemanticFacts.IsSameName("target", childNode.LocalName))
{
EmailAndPhoneNoMustNotBePresentInTheSource.VerifyValue(new Action <Diagnostic>(compilationAnalysisContext.ReportDiagnostic), childNode.InnerText, propertyLocation, xliffLanguageFile, string.Format("{0}:{1}", (object)str, (object)childNode.LocalName));
}
}
}
}
catch (Exception ex)
{
GlobalLogger.LogException(ex);
}
}
}
private static void AnalyzeCompoundAssignmentStatementIdentifier(
IdentifierNameSyntax identifier,
Dictionary <string, IdentifierNameSyntax> firstVarInitializerSyntax,
Dictionary <string, IdentifierNameSyntax> firstVarUsageSyntax)
{
// ISSUE: variable of a compiler-generated type
CompoundAssignmentStatementSyntax parent = (CompoundAssignmentStatementSyntax)identifier.Parent;
if (parent.Target.IsKind(SyntaxKind.IdentifierName) && SemanticFacts.IsSameName(((SimpleNameSyntax)parent.Target).Identifier.ValueText, identifier.Identifier.ValueText))
{
firstVarInitializerSyntax.AddIdentifierIfNotExist(identifier);
}
else
{
firstVarUsageSyntax.AddIdentifierIfNotExist(identifier);
}
}
private static PropertySyntax GetProperty(
SyntaxList <PropertySyntaxOrEmpty> properties,
string propertyName)
{
foreach (PropertySyntaxOrEmpty property in properties)
{
if (property.Kind != SyntaxKind.EmptyProperty)
{
PropertySyntax propertySyntax = (PropertySyntax)property;
if (SemanticFacts.IsSameName(propertySyntax.Name.Identifier.ValueText, propertyName))
{
return(propertySyntax);
}
}
}
return((PropertySyntax)null);
}
public static bool IsNullable(Compilation compilation, ITypeSymbol type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (type.NullableAnnotation == NullableAnnotation.Annotated)
{
return(true);
}
else if (type is INamedTypeSymbol namedType)
{
return(SemanticFacts.IsNullableT(compilation, namedType));
}
return(false);
}
internal static bool VerifyIdentifierIsInMethodTriggerVarParamList <T>(
T methodOrTriggerDeclarationSyntax,
IdentifierNameSyntax identifier)
where T : MethodOrTriggerDeclarationSyntax
{
if (methodOrTriggerDeclarationSyntax.ParameterList != null)
{
SeparatedSyntaxList <ParameterSyntax> parameters = methodOrTriggerDeclarationSyntax.ParameterList.Parameters;
if (parameters.Count != 0)
{
parameters = methodOrTriggerDeclarationSyntax.ParameterList.Parameters;
foreach (ParameterSyntax parameterSyntax in parameters)
{
if (SemanticFacts.IsSameName(parameterSyntax.Name.Identifier.ValueText, identifier.Identifier.ValueText))
{
return(true);
}
}
}
}
if (methodOrTriggerDeclarationSyntax.Variables != null)
{
SyntaxList <VariableDeclarationBaseSyntax> variables = methodOrTriggerDeclarationSyntax.Variables.Variables;
if (variables.Count != 0)
{
variables = methodOrTriggerDeclarationSyntax.Variables.Variables;
foreach (SyntaxNode syntaxNode in variables)
{
if (SemanticFacts.IsSameName(syntaxNode.GetNameStringValue(), identifier.Identifier.ValueText))
{
return(true);
}
}
}
}
return(false);
}
public IParameterSymbol FindParameterForArgument(
SemanticModel semanticModel,
SyntaxNode argumentNode,
CancellationToken cancellationToken
) => SemanticFacts.FindParameterForArgument(semanticModel, argumentNode, cancellationToken);
public bool IsPartial(ITypeSymbol typeSymbol, CancellationToken cancellationToken) => SemanticFacts.IsPartial(typeSymbol, cancellationToken);
public IEnumerable <ISymbol> GetDeclaredSymbols(
SemanticModel semanticModel,
SyntaxNode memberDeclaration,
CancellationToken cancellationToken
) => SemanticFacts.GetDeclaredSymbols(semanticModel, memberDeclaration, cancellationToken);
public IMethodSymbol GetGetAwaiterMethod(SemanticModel semanticModel, SyntaxNode node) => SemanticFacts.GetGetAwaiterMethod(semanticModel, node);
public ImmutableArray <IMethodSymbol> GetDeconstructionForEachMethods(
SemanticModel semanticModel,
SyntaxNode node
) => SemanticFacts.GetDeconstructionForEachMethods(semanticModel, node);
public ImmutableHashSet <string> GetAliasNameSet(
SemanticModel model,
CancellationToken cancellationToken
) => SemanticFacts.GetAliasNameSet(model, cancellationToken);
public ForEachSymbols GetForEachSymbols(
SemanticModel semanticModel,
SyntaxNode forEachStatement
) => SemanticFacts.GetForEachSymbols(semanticModel, forEachStatement);
public ImmutableArray <ISymbol> GetBestOrAllSymbols(
SemanticModel semanticModel,
SyntaxNode node,
SyntaxToken token,
CancellationToken cancellationToken
) => SemanticFacts.GetBestOrAllSymbols(semanticModel, node, token, cancellationToken);
public bool LastEnumValueHasInitializer(INamedTypeSymbol namedTypeSymbol) => SemanticFacts.LastEnumValueHasInitializer(namedTypeSymbol);
public ISymbol GetDeclaredSymbol(
SemanticModel semanticModel,
SyntaxToken token,
CancellationToken cancellationToken
) => SemanticFacts.GetDeclaredSymbol(semanticModel, token, cancellationToken);
public bool CanReplaceWithRValue(
SemanticModel semanticModel,
SyntaxNode expression,
CancellationToken cancellationToken
) => SemanticFacts.CanReplaceWithRValue(semanticModel, expression, cancellationToken);
public bool IsInInContext(
SemanticModel semanticModel,
SyntaxNode node,
CancellationToken cancellationToken
) => SemanticFacts.IsInInContext(semanticModel, node, cancellationToken);
public bool IsInsideNameOfExpression(
SemanticModel semanticModel,
SyntaxNode node,
CancellationToken cancellationToken
) => SemanticFacts.IsInsideNameOfExpression(semanticModel, node, cancellationToken);
public bool IsOnlyWrittenTo(
SemanticModel semanticModel,
SyntaxNode node,
CancellationToken cancellationToken
) => SemanticFacts.IsOnlyWrittenTo(semanticModel, node, cancellationToken);
