/// <summary> /// Returns the System.String that represents the current TypedConstant. /// </summary> /// <returns>A System.String that represents the current TypedConstant.</returns> public static ExpressionSyntax ToExpression(this TypedConstant constant) { if (constant.IsNull) { return(LiteralExpression(SyntaxKind.NullLiteralExpression)); } if (constant.Kind == TypedConstantKind.Array) { throw new NotSupportedException($"Unsupported TypedConstant: {constant.ToCSharpString()}"); } if (constant.Kind == TypedConstantKind.Type) { Debug.Assert(constant.Value is object); return(TypeOfExpression(((ITypeSymbol)constant.Value).ToTypeSyntax())); } if (constant.Kind == TypedConstantKind.Enum) { return(DisplayEnumConstant(constant)); } return(ParseExpression(constant.ToCSharpString())); }
/// <summary> /// Gets the display string of <see cref="InsecureSymbol"/> or <see cref="InsecureAttribute"/>. /// </summary> /// <returns>Display string of <see cref="InsecureSymbol"/> or <see cref="InsecureAttribute"/>.</returns> public string GetDisplayString() { if (this.InsecureSymbol != null) { return(this.InsecureSymbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); } else if (this.InsecureAttributeTypedConstant != null) { TypedConstant t = (TypedConstant)this.InsecureAttributeTypedConstant !; return(t.ToCSharpString()); } else { throw new NotImplementedException("Unhandled case"); } }
private static ImmutableHashSet <string> GetDirectImmutableException(AttributeData attrData) { SyntaxNode syntaxNode = attrData .ApplicationSyntaxReference? .GetSyntax(); AttributeSyntax attrSyntax = syntaxNode as AttributeSyntax; ExpressionSyntax flagsExpression; // If we can't get the attribute syntax but we know the Immutable attribute exists, we're analyzing a type // from another assembly. We can analyze it by parsing its value back into syntax. if (attrSyntax == null) { TypedConstant exceptValue = attrData .NamedArguments .FirstOrDefault(kvp => kvp.Key == "Except") .Value; flagsExpression = exceptValue.IsNull ? null : SyntaxFactory.ParseExpression(exceptValue.ToCSharpString()); } else { AttributeArgumentSyntax foundArg = attrSyntax .ArgumentList? .Arguments .FirstOrDefault( // Get the first argument that is defined by the "Except = ..." syntax arg => arg.NameEquals?.Name?.Identifier.ValueText == "Except" ); flagsExpression = foundArg?.Expression; } if (flagsExpression == null) { // We have the Immutable attribute but no Except value, so we just return the defaults return(DefaultImmutabilityExceptions); } var set = ExceptFlagValuesToSet(flagsExpression); return(set); }
protected override string ToString(TypedConstant typedConstant) => typedConstant.ToCSharpString();
void Format(InlineCollection block, TypedConstant constant) { if (constant.IsNull) { block.Add("null".Render(Keyword)); return; } switch (constant.Kind) { case TypedConstantKind.Primitive: if (constant.Value is bool) { block.Add(WpfHelper.Render((bool)constant.Value ? "true" : "false", Keyword)); } else if (constant.Value is string) { block.Add(constant.ToCSharpString().Render(Text)); } else { block.Add(constant.ToCSharpString().Render(Number)); } break; case TypedConstantKind.Enum: var en = constant.ToCSharpString(); if (en.IndexOf('|') != -1) { var items = constant.Type.GetMembers().Where(i => { var field = i as IFieldSymbol; return(field != null && field.HasConstantValue && UnsafeArithmeticHelper.Equals(UnsafeArithmeticHelper.And(constant.Value, field.ConstantValue), field.ConstantValue) && UnsafeArithmeticHelper.IsZero(field.ConstantValue) == false); }); var flags = items.ToArray(); for (int i = 0; i < flags.Length; i++) { if (i > 0) { block.Add(" | "); } block.Add((constant.Type.Name + "." + flags[i].Name).Render(Enum)); } } else { block.Add((constant.Type.Name + en.Substring(en.LastIndexOf('.'))).Render(Enum)); } break; case TypedConstantKind.Type: block.Add("typeof".Render(Keyword)); block.Add("("); Format(block, constant.Value as ISymbol, null, false); block.Add(")"); break; case TypedConstantKind.Array: block.Add("new".Render(Keyword)); block.Add("[] { "); bool c = false; foreach (var item in constant.Values) { if (c) { block.Add(", "); } else { c = true; } Format(block, item); } block.Add(" }"); break; default: block.Add(constant.ToCSharpString()); break; } }
private static string GetArgumentValue(TypedConstant typedConstant) { switch (typedConstant.Kind) { case TypedConstantKind.Error: case TypedConstantKind.Enum: case TypedConstantKind.Primitive: return typedConstant.Value.ToString(); case TypedConstantKind.Type: case TypedConstantKind.Array: return typedConstant.ToCSharpString(); default: throw new ArgumentOutOfRangeException(nameof(typedConstant)); } }
internal void ToUIText(TextBlock block, TypedConstant constant) { switch (constant.Kind) { case TypedConstantKind.Primitive: if (constant.Value is bool) { block.Append((bool)constant.Value ? "true" : "false", Keyword); } else if (constant.Value is string) { block.Append(constant.ToCSharpString(), Text); } else { block.Append(constant.ToCSharpString(), Number); } break; case TypedConstantKind.Enum: var en = constant.ToCSharpString(); if (en.IndexOf('|') != -1) { var items = constant.Type.GetMembers().Where(i => { var field = i as IFieldSymbol; return(field != null && field.HasConstantValue != false && UnsafeArithmeticHelper.Equals(UnsafeArithmeticHelper.And(constant.Value, field.ConstantValue), field.ConstantValue) && UnsafeArithmeticHelper.IsZero(field.ConstantValue) == false); }); var flags = items.ToArray(); for (int i = 0; i < flags.Length; i++) { if (i > 0) { block.Append(" | "); } block.Append(constant.Type.Name + "." + flags[i].Name, Enum); } } else { block.Append(constant.Type.Name + en.Substring(en.LastIndexOf('.')), Enum); } break; case TypedConstantKind.Type: block.Append("typeof", Keyword).Append("(") .AddSymbol((constant.Value as ITypeSymbol), null, this) .Append(")"); break; case TypedConstantKind.Array: block.Append("{"); bool c = false; foreach (var item in constant.Values) { if (c == false) { c = true; } else { block.Append(", "); } ToUIText(block, item); } block.Append("}"); break; default: block.Append(constant.ToCSharpString()); break; } }