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);