public void WriteType(IOutputWriter output, IDebuggerType type, TypeFormatFlags flags) => debugger.Dispatcher.UI(() => CorValue.WriteType(new OutputWriterConverter(output), ((DebuggerType)type).CorType, (TypePrinterFlags)flags));
/// <summary> /// Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope /// Meaning needs to be specified if the enclosing declaration is given /// </summary> private void BuildSymbolDisplay(ISymbol inputSymbol, ISymbolWriter writer, INode enclosingDeclaration = null, SymbolFlags inputMeaning = SymbolFlags.None, SymbolFormatFlags flags = SymbolFormatFlags.None, TypeFormatFlags typeFlags = TypeFormatFlags.None) { Contract.Assert(inputSymbol != null); Contract.Assert(writer != null); // HINT: To simplify migration we're using "local" functions via delegates. // This code could be changed in the future, once C# would have local functions. Action <ISymbol, SymbolFlags> walkSymbol = null; ISymbol parentSymbol = null; Action <ISymbol> appendParentTypeArgumentsAndSymbolName = null; appendParentTypeArgumentsAndSymbolName = (ISymbol symbol) => { if (parentSymbol != null) { // Write type arguments of instantiated class/interface here if ((flags & SymbolFormatFlags.WriteTypeParametersOrArguments) != SymbolFormatFlags.None) { if ((symbol.Flags & SymbolFlags.Instantiated) != SymbolFlags.None) { // TODO: check types to avoid redundant ToArray call. BuildDisplayForTypeArgumentsAndDelimiters( m_checker.GetTypeParametersOfClassOrInterface(parentSymbol), ((ITransientSymbol)symbol).Mapper, writer, enclosingDeclaration); } else { BuildTypeParameterDisplayFromSymbol(parentSymbol, writer, enclosingDeclaration); } } WritePunctuation(writer, SyntaxKind.DotToken); } parentSymbol = symbol; AppendSymbolNameOnly(symbol, writer); }; // Let the writer know we just wrote out a symbol. The declaration emitter writer uses // this to determine if an import it has previously seen (and not written out) needs // to be written to the file once the walk of the tree is complete. // // NOTE(cyrusn): This approach feels somewhat unfortunate. A simple pass over the tree // up front (for example, during checking) could determine if we need to emit the imports // and we could then access that data during declaration emit. writer.TrackSymbol(inputSymbol, enclosingDeclaration, inputMeaning); walkSymbol = (ISymbol symbol, SymbolFlags meaning) => { if (symbol != null) { var accessibleSymbolChain = m_checker.GetAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, (flags & SymbolFormatFlags.UseOnlyExternalAliasing) != SymbolFormatFlags.None); if (accessibleSymbolChain == null || m_checker.NeedsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.Count == 1 ? meaning : GetQualifiedLeftMeaning(meaning))) { // Go up and add our parent. walkSymbol( m_checker.GetParentOfSymbol(accessibleSymbolChain != null ? accessibleSymbolChain[0] : symbol), GetQualifiedLeftMeaning(meaning)); } if (accessibleSymbolChain != null) { foreach (var accessibleSymbol in accessibleSymbolChain) { appendParentTypeArgumentsAndSymbolName(accessibleSymbol); } } else { // If we didn't find accessible symbol chain for this symbol, break if this is external module if (parentSymbol == null && symbol.DeclarationList.Any(n => HasExternalModuleSymbol(n))) { return; } // if this is anonymous type break if ((symbol.Flags & SymbolFlags.TypeLiteral) != SymbolFlags.None || (symbol.Flags & SymbolFlags.ObjectLiteral) != SymbolFlags.None) { return; } appendParentTypeArgumentsAndSymbolName(symbol); } } }; // Get qualified name if the symbol is not a type parameter // and there is an enclosing declaration or we specifically // asked for it var isTypeParameter = inputSymbol.Flags & SymbolFlags.TypeParameter; var typeFormatFlag = TypeFormatFlags.UseFullyQualifiedType & typeFlags; if (isTypeParameter == SymbolFlags.None && (enclosingDeclaration != null || typeFormatFlag != TypeFormatFlags.None)) { walkSymbol(inputSymbol, inputMeaning); return; } appendParentTypeArgumentsAndSymbolName(inputSymbol); }
public void Write(IOutputWriter output, ValueResult valueResult, TypeFormatFlags flags) => debugger.Dispatcher.UI(() => valueResult.ToCorValueResult().Write(new OutputWriterConverter(output), this.CorValue, (TypePrinterFlags)flags));
void ISymbolDisplayBuilder.BuildTypeParameterDisplayFromSymbol(ISymbol symbol, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags) { BuildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaration, flags, symbolStack: null); }
void ISymbolDisplayBuilder.BuildDisplayForTypeParametersAndDelimiters(List <ITypeParameter> typeParameters, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags) { BuildDisplayForTypeParametersAndDelimiters(typeParameters, writer, enclosingDeclaration, flags, symbolStack: null); }
public void Write(ISyntaxHighlightOutput output, ValueResult valueResult, TypeFormatFlags flags) { debugger.Dispatcher.UI(() => valueResult.ToCorValueResult().Write(new OutputConverter(output), this.value, (TypePrinterFlags)flags)); }
public void WriteType(ISyntaxHighlightOutput output, IDebuggerType type, TypeFormatFlags flags) { debugger.Dispatcher.UI(() => value.WriteType(new OutputConverter(output), ((DebuggerType)type).CorType, (TypePrinterFlags)flags)); }
public string ToString(TypeFormatFlags flags) { return(debugger.Dispatcher.UI(() => value.ToString((TypePrinterFlags)flags))); }
public void Write(ISyntaxHighlightOutput output, TypeFormatFlags flags) { debugger.Dispatcher.UI(() => evt.Write(new OutputConverter(output), (TypePrinterFlags)flags)); }
public string ToString(TypeFormatFlags flags) => debugger.Dispatcher.UI(() => this.CorFunction.ToString((TypePrinterFlags)flags));
/// <summary> /// ToString() /// </summary> /// <param name="value">Owner <see cref="IDebuggerValue"/> instance</param> /// <param name="flags">Flags</param> /// <returns></returns> public string ToString(IDebuggerValue value, TypeFormatFlags flags = TypeFormatFlags.Default) => value.ToString(this, flags);
public void Write(IOutputWriter output, TypeFormatFlags flags) => debugger.Dispatcher.UI(() => evt.Write(new OutputWriterConverter(output), (TypePrinterFlags)flags));
public void Write(IOutputWriter output, TypeFormatFlags flags) => debugger.Dispatcher.UI(() => CorFunction.Write(new OutputWriterConverter(output), (TypePrinterFlags)flags));
/// <summary> /// Write this to <paramref name="output"/> /// </summary> /// <param name="output">Destination</param> /// <param name="value">Owner <see cref="IDebuggerValue"/> instance</param> /// <param name="flags">Flags</param> public void Write(ISyntaxHighlightOutput output, IDebuggerValue value, TypeFormatFlags flags) { value.Write(output, this, flags); }
private void BuildTypeDisplay(IType inputType, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags globalFlags, Stack <ISymbol> symbolStack = null) { var globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike; var inObjectTypeLiteral = false; WriteType(inputType, globalFlags); return; void WriteType(IType type, TypeFormatFlags flags) { // Write null/null type as any if ((type.Flags & TypeFlags.Intrinsic) != TypeFlags.None) { if ((type.Flags & TypeFlags.PredicateType) != TypeFlags.None) { BuildTypePredicateDisplay(writer, type.Cast <IPredicateType>().Predicate); BuildTypeDisplay(type.Cast <IPredicateType>().Predicate.Type, writer, enclosingDeclaration, flags, symbolStack); } else { // Special handling for unknown / resolving types, they should show up as any and not unknown or __resolving writer.WriteKeyword((globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike) == TypeFormatFlags.None && IsTypeAny(type) ? "any" : type.Cast <IIntrinsicType>().IntrinsicName); } } else if ((type.Flags & TypeFlags.ThisType) != TypeFlags.None) { if (inObjectTypeLiteral) { writer.ReportInaccessibleThisError(); } writer.WriteKeyword("this"); } else if ((type.Flags & TypeFlags.Reference) != TypeFlags.None) { WriteTypeReference((ITypeReference)type, flags); } else if ((type.Flags & (TypeFlags.Class | TypeFlags.Interface | TypeFlags.Enum | TypeFlags.TypeParameter)) != TypeFlags.None) { // The specified symbol flags need to be reinterpreted as type flags BuildSymbolDisplay(type.Symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags); } else if ((type.Flags & TypeFlags.Tuple) != TypeFlags.None) { WriteTupleType((ITupleType)type); } else if ((type.Flags & TypeFlags.UnionOrIntersection) != TypeFlags.None) { WriteUnionOrIntersectionType(type.Cast <IUnionOrIntersectionType>(), flags); } else if ((type.Flags & TypeFlags.Anonymous) != TypeFlags.None) { WriteAnonymousType((IObjectType)type, flags); } else if ((type.Flags & TypeFlags.StringLiteral) != TypeFlags.None) { writer.WriteStringLiteral(I($"\"{TextUtilities.EscapeString(((IStringLiteralType)type).Text)}\"")); } else { // Should never get here // { ... } WritePunctuation(writer, SyntaxKind.OpenBraceToken); WriteSpace(writer); WritePunctuation(writer, SyntaxKind.DotDotDotToken); WriteSpace(writer); WritePunctuation(writer, SyntaxKind.CloseBraceToken); } } void WriteTypeList(IReadOnlyList <IType> types, SyntaxKind delimiter) { for (var i = 0; i < types.Count; i++) { if (i > 0) { if (delimiter != SyntaxKind.CommaToken) { WriteSpace(writer); } WritePunctuation(writer, delimiter); WriteSpace(writer); } WriteType(types[i], delimiter == SyntaxKind.CommaToken ? TypeFormatFlags.None : TypeFormatFlags.InElementType); } } void WriteSymbolTypeReference(ISymbol symbol, IReadOnlyList <IType> typeArguments, int pos, int end, TypeFormatFlags flags) { // Unnamed expressions and arrow functions have reserved names that we don't want to display if ((symbol.Flags & SymbolFlags.Class) != SymbolFlags.None || !IsReservedMemberName(symbol.Name)) { BuildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags); } if (pos < end) { WritePunctuation(writer, SyntaxKind.LessThanToken); WriteType(typeArguments[pos++], TypeFormatFlags.None); while (pos < end) { WritePunctuation(writer, SyntaxKind.CommaToken); WriteSpace(writer); WriteType(typeArguments[pos++], TypeFormatFlags.None); } WritePunctuation(writer, SyntaxKind.GreaterThanToken); } } void WriteTypeReference(ITypeReference type, TypeFormatFlags flags) { var typeArguments = type.TypeArguments ?? new List <IType>(); if (type.Target == m_checker.m_globalArrayType && (flags & TypeFormatFlags.WriteArrayAsGenericType) == TypeFormatFlags.None) { WriteType(typeArguments[0], TypeFormatFlags.InElementType); WritePunctuation(writer, SyntaxKind.OpenBracketToken); WritePunctuation(writer, SyntaxKind.CloseBracketToken); } else { // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments // for outer type parameters, and f and g are the respective declaring containers of those // type parameters. var outerTypeParameters = type.Target.OuterTypeParameters; var i = 0; if (outerTypeParameters != null) { var length = outerTypeParameters.Count; while (i < length) { // Find group of type arguments for type parameters with the same declaring container. var start = i; var parent = m_checker.GetParentSymbolOfTypeParameter(outerTypeParameters[i]); do { i++; }while (i < length && m_checker.GetParentSymbolOfTypeParameter(outerTypeParameters[i]) == parent); // When type parameters are their own type arguments for the whole group (i.e., we have // the default outer type arguments), we don't show the group. if (!outerTypeParameters.RangeEquals(typeArguments, start, i, EqualityComparer <IType> .Default)) { WriteSymbolTypeReference(parent, typeArguments, start, i, flags); WritePunctuation(writer, SyntaxKind.DotToken); } } } var typeParameterCount = type.Target.TypeParameters?.Count ?? 0; WriteSymbolTypeReference(type.Symbol, typeArguments, i, typeParameterCount, flags); } } void WriteTupleType(ITupleType type) { WritePunctuation(writer, SyntaxKind.OpenBracketToken); WriteTypeList(type.ElementTypes, SyntaxKind.CommaToken); WritePunctuation(writer, SyntaxKind.CloseBracketToken); } void WriteUnionOrIntersectionType(IUnionOrIntersectionType type, TypeFormatFlags flags) { if ((flags & TypeFormatFlags.InElementType) != TypeFormatFlags.None) { WritePunctuation(writer, SyntaxKind.OpenParenToken); } WriteTypeList(type.Types, (type.Flags & TypeFlags.Union) != TypeFlags.None ? SyntaxKind.BarToken : SyntaxKind.AmpersandToken); if ((flags & TypeFormatFlags.InElementType) != TypeFormatFlags.None) { WritePunctuation(writer, SyntaxKind.CloseParenToken); } } void WriteAnonymousType(IObjectType type, TypeFormatFlags flags) { var symbol = type.Symbol; if (symbol != null) { // Always use 'typeof T' for type of class, enum, and module objects if ((symbol.Flags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) != SymbolFlags.None) { WriteTypeofSymbol(type, flags); } else if (ShouldWriteTypeOfFunctionSymbol(symbol, flags)) { WriteTypeofSymbol(type, flags); } else if (symbolStack?.Contains(symbol) == true) { // If type is an anonymous type literal in a type alias declaration, use type alias name var typeAlias = m_checker.GetTypeAliasForTypeLiteral(type); if (typeAlias != null) { // The specified symbol flags need to be reinterpreted as type flags BuildSymbolDisplay(typeAlias, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags); } else { // Recursive usage, use any WriteKeyword(writer, SyntaxKind.AnyKeyword); } } else { // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead // of types allows us to catch circular references to instantiations of the same anonymous type if (symbolStack == null) { symbolStack = new Stack <ISymbol>(); } symbolStack.Push(symbol); WriteLiteralType(type, flags); symbolStack.Pop(); } } else { // Anonymous types with no symbol are never circular WriteLiteralType(type, flags); } } void WriteTypeofSymbol(IObjectType type, TypeFormatFlags typeFormatFlags) { WriteKeyword(writer, SyntaxKind.TypeOfKeyword); WriteSpace(writer); BuildSymbolDisplay(type.Symbol, writer, enclosingDeclaration, SymbolFlags.Value, SymbolFormatFlags.None, typeFormatFlags); } string GetIndexerParameterName(IObjectType type, IndexKind indexKind, string fallbackName) { var declaration = GetIndexDeclarationOfSymbol(type.Symbol, indexKind); if (declaration == null) { // declaration might not be found if indexer was added from the contextual type. // in this case use fallback name return(fallbackName); } Contract.Assert(declaration.Parameters.Length != 0); return(DeclarationNameToString(declaration.Parameters[0].Name)); } void WriteLiteralType(IObjectType type, TypeFormatFlags flags) { IResolvedType resolved = m_checker.ResolveStructuredTypeMembers(type); if (resolved.Properties.Count == 0 && resolved.StringIndexType == null && resolved.NumberIndexType == null) { if (resolved.CallSignatures.Count == 0 && resolved.ConstructSignatures.Count == 0) { WritePunctuation(writer, SyntaxKind.OpenBraceToken); WritePunctuation(writer, SyntaxKind.CloseBraceToken); return; } if (resolved.CallSignatures.Count == 1 && resolved.ConstructSignatures.Count == 0) { if ((flags & TypeFormatFlags.InElementType) != TypeFormatFlags.None) { WritePunctuation(writer, SyntaxKind.OpenParenToken); } BuildSignatureDisplay(resolved.CallSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature, /*kind*/ null, symbolStack); if ((flags & TypeFormatFlags.InElementType) != TypeFormatFlags.None) { WritePunctuation(writer, SyntaxKind.CloseParenToken); } return; } if (resolved.ConstructSignatures.Count == 1 && resolved.CallSignatures.Count == 0) { if ((flags & TypeFormatFlags.InElementType) != TypeFormatFlags.None) { WritePunctuation(writer, SyntaxKind.OpenParenToken); } WriteKeyword(writer, SyntaxKind.NewKeyword); WriteSpace(writer); BuildSignatureDisplay(resolved.ConstructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | TypeFormatFlags.WriteArrowStyleSignature, /*kind*/ null, symbolStack); if ((flags & TypeFormatFlags.InElementType) != TypeFormatFlags.None) { WritePunctuation(writer, SyntaxKind.CloseParenToken); } return; } } var saveInObjectTypeLiteral = inObjectTypeLiteral; inObjectTypeLiteral = true; WritePunctuation(writer, SyntaxKind.OpenBraceToken); writer.WriteLine(); writer.IncreaseIndent(); foreach (var signature in resolved.CallSignatures.AsStructEnumerable()) { BuildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, /*kind*/ null, symbolStack); WritePunctuation(writer, SyntaxKind.SemicolonToken); writer.WriteLine(); } foreach (var signature in resolved.ConstructSignatures.AsStructEnumerable()) { BuildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, SignatureKind.Construct, symbolStack); WritePunctuation(writer, SyntaxKind.SemicolonToken); writer.WriteLine(); } if (resolved.StringIndexType != null) { // [string x]: WritePunctuation(writer, SyntaxKind.OpenBracketToken); writer.WriteParameter(GetIndexerParameterName(resolved, IndexKind.String, /*fallbackName*/ "x")); WritePunctuation(writer, SyntaxKind.ColonToken); WriteSpace(writer); WriteKeyword(writer, SyntaxKind.StringKeyword); WritePunctuation(writer, SyntaxKind.CloseBracketToken); WritePunctuation(writer, SyntaxKind.ColonToken); WriteSpace(writer); WriteType(resolved.StringIndexType, TypeFormatFlags.None); WritePunctuation(writer, SyntaxKind.SemicolonToken); writer.WriteLine(); } if (resolved.NumberIndexType != null) { // [int x]: WritePunctuation(writer, SyntaxKind.OpenBracketToken); writer.WriteParameter(GetIndexerParameterName(resolved, IndexKind.Number, /*fallbackName*/ "x")); WritePunctuation(writer, SyntaxKind.ColonToken); WriteSpace(writer); WriteKeyword(writer, SyntaxKind.NumberKeyword); WritePunctuation(writer, SyntaxKind.CloseBracketToken); WritePunctuation(writer, SyntaxKind.ColonToken); WriteSpace(writer); WriteType(resolved.NumberIndexType, TypeFormatFlags.None); WritePunctuation(writer, SyntaxKind.SemicolonToken); writer.WriteLine(); } foreach (var p in resolved.Properties.AsStructEnumerable()) { var t = m_checker.GetTypeOfSymbol(p); if ((p.Flags & (SymbolFlags.Function | SymbolFlags.Method)) != SymbolFlags.None && m_checker.GetPropertiesOfObjectType(t).Count == 0) { var signatures = m_checker.GetSignaturesOfType(t, SignatureKind.Call); foreach (var signature in signatures.AsStructEnumerable()) { BuildSymbolDisplay(p, writer); if ((p.Flags & SymbolFlags.Optional) != SymbolFlags.None) { WritePunctuation(writer, SyntaxKind.QuestionToken); } BuildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, /*kind*/ null, symbolStack); WritePunctuation(writer, SyntaxKind.SemicolonToken); writer.WriteLine(); } } else { BuildSymbolDisplay(p, writer); if ((p.Flags & SymbolFlags.Optional) != SymbolFlags.None) { WritePunctuation(writer, SyntaxKind.QuestionToken); } WritePunctuation(writer, SyntaxKind.ColonToken); WriteSpace(writer); WriteType(t, TypeFormatFlags.None); WritePunctuation(writer, SyntaxKind.SemicolonToken); writer.WriteLine(); } } writer.DecreaseIndent(); WritePunctuation(writer, SyntaxKind.CloseBraceToken); inObjectTypeLiteral = saveInObjectTypeLiteral; } bool ShouldWriteTypeOfFunctionSymbol(ISymbol symbol, TypeFormatFlags flags) { var isStaticMethodSymbol = ((symbol.Flags & SymbolFlags.Method) != SymbolFlags.None && // typeof static method symbol.DeclarationList.Any(declaration => (declaration.Flags & NodeFlags.Static) != NodeFlags.None)) == true; var isNonLocalFunctionSymbol = (symbol.Flags & SymbolFlags.Function) != SymbolFlags.None && (symbol.Parent != null || // is exported symbol symbol.DeclarationList.Any(declaration => declaration.Parent.Kind == SyntaxKind.SourceFile || declaration.Parent.Kind == SyntaxKind.ModuleBlock)); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { // typeof is allowed only for static/non local functions return((flags & TypeFormatFlags.UseTypeOfFunction) != TypeFormatFlags.None || // use typeof if format flags specify it symbolStack?.Contains(symbol) == true); // it is type of the symbol uses itself recursively } return(false); } }
public void Write(ISyntaxHighlightOutput output, TypeFormatFlags flags) { debugger.Dispatcher.UI(() => prop.Write(new OutputConverter(output), (TypePrinterFlags)flags)); }
private void WriteTypeOfSymbol(ISymbolWriter writer, IObjectType type, TypeFormatFlags typeFormatFlags, INode enclosingDeclaration = null) { WriteKeyword(writer, SyntaxKind.TypeOfKeyword); WriteSpace(writer); BuildSymbolDisplay(type.Symbol, writer, enclosingDeclaration, SymbolFlags.Value, SymbolFormatFlags.None, typeFormatFlags); }
void ISymbolDisplayBuilder.BuildParameterDisplay(ISymbol parameter, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags) { BuildParameterDisplay(parameter, writer, enclosingDeclaration, flags, symbolStack: null); }
private void BuildTypeParameterDisplayFromSymbol(ISymbol symbol, ISymbolWriter writer, INode enclosingDeclaraiton, TypeFormatFlags flags = TypeFormatFlags.None, Stack <ISymbol> symbolStack = null) { var targetSymbol = m_checker.GetTargetSymbol(symbol); if ((targetSymbol.Flags & SymbolFlags.Class) != SymbolFlags.None || (targetSymbol.Flags & SymbolFlags.Interface) != SymbolFlags.None || (targetSymbol.Flags & SymbolFlags.TypeAlias) != SymbolFlags.None) { BuildDisplayForTypeParametersAndDelimiters(m_checker.GetLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaraiton, flags, symbolStack); } }
void ISymbolDisplayBuilder.BuildDisplayForParametersAndDelimiters(List <ISymbol> parameters, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags) { BuildDisplayForParametersAndDelimiters(parameters?.ToArray(), writer, enclosingDeclaration, flags, symbolStack: null); }
private void BuildTypeParameterDisplay(ITypeParameter tp, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, Stack <ISymbol> symbolStack) { AppendSymbolNameOnly(tp.Symbol, writer); var varraint = m_checker.GetConstraintOfTypeParameter(tp); if (varraint != null) { WriteSpace(writer); WriteKeyword(writer, SyntaxKind.ExtendsKeyword); WriteSpace(writer); BuildTypeDisplay(varraint, writer, enclosingDeclaration, flags, symbolStack); } }
void ISymbolDisplayBuilder.BuildReturnTypeDisplay(ISignature signature, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags) { BuildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, symbolStack: null); }
private void BuildParameterDisplay(ISymbol p, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, Stack <ISymbol> symbolStack) { var parameterNode = p.ValueDeclaration.Cast <IParameterDeclaration>(); if (IsRestParameter(parameterNode)) { WritePunctuation(writer, SyntaxKind.DotDotDotToken); } AppendSymbolNameOnly(p, writer); if (m_checker.IsOptionalParameter(parameterNode)) { WritePunctuation(writer, SyntaxKind.QuestionToken); } WritePunctuation(writer, SyntaxKind.ColonToken); WriteSpace(writer); BuildTypeDisplay(m_checker.GetTypeOfSymbol(p), writer, enclosingDeclaration, flags, symbolStack); }
/// <inheritdoc/> public bool TryPrintType(IType type, out string result, INode enclosingDeclaration = null, TypeFormatFlags flags = TypeFormatFlags.None) { Contract.Requires(type != null, "type != null"); var writer = SymbolWriterPool.GetSingleLineStringWriter(TypeChecker); result = TypeChecker.TypeToString(type, enclosingDeclaration, flags, writer); SymbolWriterPool.ReleaseStringWriter(writer); return(!writer.IsInaccessibleErrorReported()); }
private void BuildDisplayForTypeParametersAndDelimiters(IReadOnlyList <ITypeParameter> typeParameters, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, Stack <ISymbol> symbolStack) { if (typeParameters != null && typeParameters.Count != 0) { WritePunctuation(writer, SyntaxKind.LessThanToken); for (var i = 0; i < typeParameters.Count; i++) { if (i > 0) { WritePunctuation(writer, SyntaxKind.CommaToken); WriteSpace(writer); } BuildTypeParameterDisplay(typeParameters[i], writer, enclosingDeclaration, flags, symbolStack); } WritePunctuation(writer, SyntaxKind.GreaterThanToken); } }
public string ToString(ValueResult valueResult, TypeFormatFlags flags) => debugger.Dispatcher.UI(() => valueResult.ToCorValueResult().ToString(this.CorValue, (TypePrinterFlags)flags));
private void BuildDisplayForParametersAndDelimiters(IReadOnlyList <ISymbol> parameters, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, Stack <ISymbol> symbolStack) { WritePunctuation(writer, SyntaxKind.OpenParenToken); for (var i = 0; i < parameters.Count; i++) { if (i > 0) { WritePunctuation(writer, SyntaxKind.CommaToken); WriteSpace(writer); } BuildParameterDisplay(parameters[i], writer, enclosingDeclaration, flags, symbolStack); } WritePunctuation(writer, SyntaxKind.CloseParenToken); }
public string ToString(TypeFormatFlags flags) => debugger.Dispatcher.UI(() => this.CorValue.ToString((TypePrinterFlags)flags));
private void BuildReturnTypeDisplay(ISignature signature, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, Stack <ISymbol> symbolStack) { if ((flags & TypeFormatFlags.WriteArrowStyleSignature) != TypeFormatFlags.None) { WriteSpace(writer); WritePunctuation(writer, SyntaxKind.EqualsGreaterThanToken); } else { WritePunctuation(writer, SyntaxKind.ColonToken); } WriteSpace(writer); var returnType = m_checker.GetReturnTypeOfSignature(signature); BuildTypeDisplay(returnType, writer, enclosingDeclaration, flags, symbolStack); }
public string ToString(TypeFormatFlags flags) => debugger.Dispatcher.UI(() => evt.ToString((TypePrinterFlags)flags));
private void BuildSignatureDisplay(ISignature signature, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, SignatureKind?kind, Stack <ISymbol> symbolStack) { if (kind == SignatureKind.Construct) { WriteKeyword(writer, SyntaxKind.NewKeyword); WriteSpace(writer); } if (signature.Target != null && ((flags & TypeFormatFlags.WriteTypeArgumentsOfSignature) != TypeFormatFlags.None)) { // Instantiated signature, write type arguments instead // This is achieved by passing in the mapper separately BuildDisplayForTypeArgumentsAndDelimiters(signature.Target.TypeParameters, signature.Mapper, writer, enclosingDeclaration); } else { BuildDisplayForTypeParametersAndDelimiters(signature.TypeParameters, writer, enclosingDeclaration, flags, symbolStack); } BuildDisplayForParametersAndDelimiters(signature.Parameters, writer, enclosingDeclaration, flags, symbolStack); BuildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, symbolStack); }
/// <summary> /// ToString() /// </summary> /// <param name="value">Owner <see cref="IDebuggerValue"/> instance</param> /// <param name="flags">Flags</param> /// <returns></returns> public string ToString(IDebuggerValue value, TypeFormatFlags flags) { return(value.ToString(this, flags)); }
void ISymbolDisplayBuilder.BuildTypeDisplay(IType inputType, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags globalFlags) { BuildTypeDisplay(inputType, writer, enclosingDeclaration, globalFlags, symbolStack: null); }
void ISymbolDisplayBuilder.BuildSignatureDisplay(ISignature signatures, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, SignatureKind kind) { BuildSignatureDisplay(signatures, writer, enclosingDeclaration, flags, kind, symbolStack: null); }
public string ToString(TypeFormatFlags flags) { return debugger.Dispatcher.UI(() => prop.ToString((TypePrinterFlags)flags)); }
public string ToString(TypeFormatFlags flags) => debugger.Dispatcher.UI(() => field.ToString((TypePrinterFlags)flags));