private string GetVariablePrototype( EnumMemberDeclarationSyntax node, IFieldSymbol symbol, PrototypeFlags flags ) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. throw Exceptions.ThrowEInvalidArg(); } // The unique signature is simply the node key. return(GetNodeKey(node).Name); } var builder = new StringBuilder(); AppendVariablePrototype(builder, symbol, flags, GetName(node)); if ( (flags & PrototypeFlags.Initializer) != 0 && node.EqualsValue != null && node.EqualsValue.Value != null && !node.EqualsValue.Value.IsMissing ) { builder.Append(" = "); builder.Append(node.EqualsValue.Value); } return(builder.ToString()); }
private void AppendParameterPrototype(StringBuilder builder, PrototypeFlags flags, IParameterSymbol parameter) { var addSpace = false; if ((flags & PrototypeFlags.ParameterTypes) != 0) { if (parameter.RefKind == RefKind.Ref) { builder.Append("ref "); } else if (parameter.RefKind == RefKind.Out) { builder.Append("out "); } else if (parameter.IsParams) { builder.Append("params "); } builder.Append(GetAsStringForCodeTypeRef(parameter.Type)); addSpace = true; } if ((flags & PrototypeFlags.ParameterNames) != 0) { if (addSpace) { builder.Append(' '); } builder.Append(parameter.Name); } }
public override string GetPrototype(SyntaxNode node, ISymbol symbol, PrototypeFlags flags) { Debug.Assert(symbol != null); if (node == null) { switch (symbol.Kind) { case SymbolKind.Field: return(GetVariablePrototype((IFieldSymbol)symbol, flags)); case SymbolKind.Method: return(GetFunctionPrototype((IMethodSymbol)symbol, flags)); case SymbolKind.Property: return(GetPropertyPrototype((IPropertySymbol)symbol, flags)); case SymbolKind.Event: return(GetEventPrototype((IEventSymbol)symbol, flags)); case SymbolKind.NamedType: var namedType = (INamedTypeSymbol)symbol; if (namedType.TypeKind == TypeKind.Delegate) { return(GetDelegatePrototype((INamedTypeSymbol)symbol, flags)); } break; } Debug.Fail("Invalid symbol kind: " + symbol.Kind); throw Exceptions.ThrowEUnexpected(); } else { switch (node) { case BaseMethodDeclarationSyntax methodDeclaration: return(GetFunctionPrototype(methodDeclaration, (IMethodSymbol)symbol, flags)); case BasePropertyDeclarationSyntax propertyDeclaration: return(GetPropertyPrototype(propertyDeclaration, (IPropertySymbol)symbol, flags)); case VariableDeclaratorSyntax variableDeclarator when symbol.Kind == SymbolKind.Field: return(GetVariablePrototype(variableDeclarator, (IFieldSymbol)symbol, flags)); case EnumMemberDeclarationSyntax enumMember: return(GetVariablePrototype(enumMember, (IFieldSymbol)symbol, flags)); case DelegateDeclarationSyntax delegateDeclaration: return(GetDelegatePrototype(delegateDeclaration, (INamedTypeSymbol)symbol, flags)); } // Crazily, events for source are not implemented by the legacy C# // code model implementation, but they are for metadata events. Debug.Fail(string.Format("Invalid node/symbol kind: {0}/{1}", node.Kind(), symbol.Kind)); throw Exceptions.ThrowENotImpl(); } }
private void AppendPropertyPrototype( StringBuilder builder, IPropertySymbol symbol, PrototypeFlags flags, string baseName ) { if ((flags & PrototypeFlags.Type) != 0) { builder.Append(GetAsStringForCodeTypeRef(symbol.Type)); if ((flags & PrototypeFlags.NameMask) != PrototypeFlags.NoName) { builder.Append(' '); } } switch (flags & PrototypeFlags.NameMask) { case PrototypeFlags.FullName: AppendTypeNamePrototype( builder, includeNamespaces: true, includeGenerics: false, symbol: symbol.ContainingSymbol ); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.TypeName: AppendTypeNamePrototype( builder, includeNamespaces: false, includeGenerics: true, symbol: symbol.ContainingSymbol ); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.BaseName: if (symbol.IsIndexer) { builder.Append("this["); AppendParametersPrototype( builder, symbol.Parameters, PrototypeFlags.ParameterTypes | PrototypeFlags.ParameterNames ); builder.Append("]"); } else { builder.Append(baseName); } break; } }
private void AppendVariablePrototype( StringBuilder builder, IFieldSymbol symbol, PrototypeFlags flags, string baseName ) { if ((flags & PrototypeFlags.Type) != 0) { builder.Append(GetAsStringForCodeTypeRef(symbol.Type)); if ((flags & PrototypeFlags.NameMask) != PrototypeFlags.NoName) { builder.Append(' '); } } switch (flags & PrototypeFlags.NameMask) { case PrototypeFlags.FullName: AppendTypeNamePrototype( builder, includeNamespaces: true, includeGenerics: false, symbol: symbol.ContainingSymbol ); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.TypeName: AppendTypeNamePrototype( builder, includeNamespaces: false, includeGenerics: true, symbol: symbol.ContainingSymbol ); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.BaseName: builder.Append(baseName); break; } }
private string GetVariablePrototype(IFieldSymbol symbol, PrototypeFlags flags) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. throw Exceptions.ThrowEInvalidArg(); } // The unique signature is simply the node key. flags = PrototypeFlags.FullName | PrototypeFlags.Type; } var builder = new StringBuilder(); AppendVariablePrototype(builder, symbol, flags, symbol.Name); return(builder.ToString()); }
private void AppendParametersPrototype( StringBuilder builder, ImmutableArray <IParameterSymbol> parameters, PrototypeFlags flags ) { var first = true; foreach (var parameter in parameters) { if (!first) { builder.Append(", "); } AppendParameterPrototype(builder, flags, parameter); first = false; } }
private string GetDelegatePrototype(INamedTypeSymbol symbol, PrototypeFlags flags) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. // Note that we only throw E_FAIL in this case. All others throw E_INVALIDARG. throw Exceptions.ThrowEFail(); } // The unique signature is simply the node key. return(GetExternalSymbolFullName(symbol)); } var builder = new StringBuilder(); AppendDelegatePrototype(builder, symbol, flags, symbol.Name); return(builder.ToString()); }
private string GetDelegatePrototype(INamedTypeSymbol symbol, PrototypeFlags flags) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. // Note that we only throw E_FAIL in this case. All others throw E_INVALIDARG. throw Exceptions.ThrowEFail(); } // The unique signature is simply the node key. return GetExternalSymbolFullName(symbol); } var builder = new StringBuilder(); AppendDelegatePrototype(builder, symbol, flags, symbol.Name); return builder.ToString(); }
private string GetPropertyPrototype( BasePropertyDeclarationSyntax node, IPropertySymbol symbol, PrototypeFlags flags ) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. throw Exceptions.ThrowEInvalidArg(); } // The unique signature is simply the node key. return(GetNodeKey(node).Name); } var builder = new StringBuilder(); AppendPropertyPrototype(builder, symbol, flags, GetName(node)); return(builder.ToString()); }
private void AppendVariablePrototype(StringBuilder builder, IFieldSymbol symbol, PrototypeFlags flags, string baseName) { if ((flags & PrototypeFlags.Type) != 0) { builder.Append(GetAsStringForCodeTypeRef(symbol.Type)); if ((flags & PrototypeFlags.NameMask) != PrototypeFlags.NoName) { builder.Append(' '); } } switch (flags & PrototypeFlags.NameMask) { case PrototypeFlags.FullName: AppendTypeNamePrototype(builder, includeNamespaces: true, includeGenerics: false, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.TypeName: AppendTypeNamePrototype(builder, includeNamespaces: false, includeGenerics: true, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.BaseName: builder.Append(baseName); break; } }
public override string GetPrototype(SyntaxNode node, ISymbol symbol, PrototypeFlags flags) { Debug.Assert(symbol != null); if (node == null) { switch (symbol.Kind) { case SymbolKind.Field: return GetVariablePrototype((IFieldSymbol)symbol, flags); case SymbolKind.Method: return GetFunctionPrototype((IMethodSymbol)symbol, flags); case SymbolKind.Property: return GetPropertyPrototype((IPropertySymbol)symbol, flags); case SymbolKind.Event: return GetEventPrototype((IEventSymbol)symbol, flags); case SymbolKind.NamedType: var namedType = (INamedTypeSymbol)symbol; if (namedType.TypeKind == TypeKind.Delegate) { return GetDelegatePrototype((INamedTypeSymbol)symbol, flags); } break; } Debug.Fail("Invalid symbol kind: " + symbol.Kind); throw Exceptions.ThrowEUnexpected(); } else { var methodDeclaration = node as BaseMethodDeclarationSyntax; if (methodDeclaration != null) { return GetFunctionPrototype(methodDeclaration, (IMethodSymbol)symbol, flags); } var propertyDeclaration = node as BasePropertyDeclarationSyntax; if (propertyDeclaration != null) { return GetPropertyPrototype(propertyDeclaration, (IPropertySymbol)symbol, flags); } var variableDeclarator = node as VariableDeclaratorSyntax; if (variableDeclarator != null && symbol.Kind == SymbolKind.Field) { return GetVariablePrototype(variableDeclarator, (IFieldSymbol)symbol, flags); } var enumMember = node as EnumMemberDeclarationSyntax; if (enumMember != null) { return GetVariablePrototype(enumMember, (IFieldSymbol)symbol, flags); } var delegateDeclaration = node as DelegateDeclarationSyntax; if (delegateDeclaration != null) { return GetDelegatePrototype(delegateDeclaration, (INamedTypeSymbol)symbol, flags); } // Crazily, events for source are not implemented by the legacy C# // code model implementation, but they are for metadata events. Debug.Fail(string.Format("Invalid node/symbol kind: {0}/{1}", node.Kind(), symbol.Kind)); throw Exceptions.ThrowENotImpl(); } }
private void AppendFunctionPrototype( StringBuilder builder, IMethodSymbol symbol, PrototypeFlags flags, string baseName ) { if ((flags & PrototypeFlags.Type) != 0) { builder.Append(GetAsStringForCodeTypeRef(symbol.ReturnType)); if ((flags & PrototypeFlags.NameMask) != PrototypeFlags.NoName) { builder.Append(' '); } } var addSpace = true; switch (flags & PrototypeFlags.NameMask) { case PrototypeFlags.FullName: AppendTypeNamePrototype( builder, includeNamespaces: true, includeGenerics: false, symbol: symbol.ContainingSymbol ); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.TypeName: AppendTypeNamePrototype( builder, includeNamespaces: false, includeGenerics: true, symbol: symbol.ContainingSymbol ); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.BaseName: builder.Append(baseName); break; case PrototypeFlags.NoName: addSpace = false; break; } if ((flags & (PrototypeFlags.ParameterNames | PrototypeFlags.ParameterTypes)) != 0) { if (addSpace) { builder.Append(' '); } builder.Append('('); AppendParametersPrototype(builder, symbol.Parameters, flags); builder.Append(')'); } }
private string GetPropertyPrototype(BasePropertyDeclarationSyntax node, IPropertySymbol symbol, PrototypeFlags flags) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. throw Exceptions.ThrowEInvalidArg(); } // The unique signature is simply the node key. return GetNodeKey(node).Name; } var builder = new StringBuilder(); AppendPropertyPrototype(builder, symbol, flags, GetName(node)); return builder.ToString(); }
private string GetVariablePrototype(IFieldSymbol symbol, PrototypeFlags flags) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. throw Exceptions.ThrowEInvalidArg(); } // The unique signature is simply the node key. flags = PrototypeFlags.FullName | PrototypeFlags.Type; } var builder = new StringBuilder(); AppendVariablePrototype(builder, symbol, flags, symbol.Name); return builder.ToString(); }
public PrototypeFlags <T> Copy(ISerializationManager serializationManager, PrototypeFlags <T> source, PrototypeFlags <T> target, bool skipHook, ISerializationContext?context = null) { return(new PrototypeFlags <T>(source)); }
private string GetVariablePrototype(EnumMemberDeclarationSyntax node, IFieldSymbol symbol, PrototypeFlags flags) { if ((flags & PrototypeFlags.Signature) != 0) { if (flags != PrototypeFlags.Signature) { // vsCMPrototypeUniqueSignature can't be combined with anything else. throw Exceptions.ThrowEInvalidArg(); } // The unique signature is simply the node key. return GetNodeKey(node).Name; } var builder = new StringBuilder(); AppendVariablePrototype(builder, symbol, flags, GetName(node)); if ((flags & PrototypeFlags.Initializer) != 0 && node.EqualsValue != null && node.EqualsValue.Value != null && !node.EqualsValue.Value.IsMissing) { builder.Append(" = "); builder.Append(node.EqualsValue.Value); } return builder.ToString(); }
private void AppendPropertyPrototype(StringBuilder builder, IPropertySymbol symbol, PrototypeFlags flags, string baseName) { if ((flags & PrototypeFlags.Type) != 0) { builder.Append(GetAsStringForCodeTypeRef(symbol.Type)); if ((flags & PrototypeFlags.NameMask) != PrototypeFlags.NoName) { builder.Append(' '); } } switch (flags & PrototypeFlags.NameMask) { case PrototypeFlags.FullName: AppendTypeNamePrototype(builder, includeNamespaces: true, includeGenerics: false, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.TypeName: AppendTypeNamePrototype(builder, includeNamespaces: false, includeGenerics: true, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.BaseName: if (symbol.IsIndexer) { builder.Append("this["); AppendParametersPrototype(builder, symbol.Parameters, PrototypeFlags.ParameterTypes | PrototypeFlags.ParameterNames); builder.Append("]"); } else { builder.Append(baseName); } break; } }
private void AppendFunctionPrototype(StringBuilder builder, IMethodSymbol symbol, PrototypeFlags flags, string baseName) { if ((flags & PrototypeFlags.Type) != 0) { builder.Append(GetAsStringForCodeTypeRef(symbol.ReturnType)); if ((flags & PrototypeFlags.NameMask) != PrototypeFlags.NoName) { builder.Append(' '); } } var addSpace = true; switch (flags & PrototypeFlags.NameMask) { case PrototypeFlags.FullName: AppendTypeNamePrototype(builder, includeNamespaces: true, includeGenerics: false, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.TypeName: AppendTypeNamePrototype(builder, includeNamespaces: false, includeGenerics: true, symbol: symbol.ContainingSymbol); builder.Append('.'); goto case PrototypeFlags.BaseName; case PrototypeFlags.BaseName: builder.Append(baseName); break; case PrototypeFlags.NoName: addSpace = false; break; } if ((flags & (PrototypeFlags.ParameterNames | PrototypeFlags.ParameterTypes)) != 0) { if (addSpace) { builder.Append(' '); } builder.Append('('); AppendParametersPrototype(builder, symbol.Parameters, flags); builder.Append(')'); } }
private void AppendParametersPrototype(StringBuilder builder, ImmutableArray<IParameterSymbol> parameters, PrototypeFlags flags) { var first = true; foreach (var parameter in parameters) { if (!first) { builder.Append(", "); } AppendParameterPrototype(builder, flags, parameter); first = false; } }
public DataNode Write(ISerializationManager serializationManager, PrototypeFlags <T> value, bool alwaysWrite = false, ISerializationContext?context = null) { return(new SequenceDataNode(value.ToArray())); }