public List <SyntaxToken> FormatParameters(OperatorSyntax syntax) { List <SyntaxToken> tokens = new List <SyntaxToken>(); List <ParameterDetails> parameters = syntax.GetParameters(); tokens.Add(new SyntaxToken("(", SyntaxTokens.Text)); for (int i = 0; i < parameters.Count; i++) { if (i != 0) { tokens.Add(new SyntaxToken(",\n\t", SyntaxTokens.Text)); } else { tokens.Add(new SyntaxToken("\n\t", SyntaxTokens.Text)); } tokens.AddRange(FormatParameterModifiers(parameters[i])); tokens.AddRange(FormatTypeDetails(parameters[i].TypeDetails)); tokens.Add(Constants.Space); tokens.Add(new SyntaxToken(parameters[i].Name, SyntaxTokens.Text)); } if (parameters.Count > 0) { tokens.Add(new SyntaxToken("\n\t", SyntaxTokens.Text)); } tokens.Add(new SyntaxToken(")", SyntaxTokens.Text)); return(tokens); }
public SyntaxTokenCollection Format(OperatorSyntax syntax) { SyntaxTokenCollection tokens = new SyntaxTokenCollection(); string identifier = syntax.GetIdentifier(); SyntaxToken inheritanceModifier = FormatInheritance(syntax); tokens.AddRange(FormatVisibility(syntax)); if (inheritanceModifier != null) { tokens.Add(Constants.Space); tokens.Add(inheritanceModifier); } if (identifier == "op_Explicit") { tokens.Add(Constants.Space); tokens.Add(new SyntaxToken("Narrowing", SyntaxTokens.Keyword)); } else if (identifier == "op_Implicit") { tokens.Add(Constants.Space); tokens.Add(new SyntaxToken("Widening", SyntaxTokens.Keyword)); } tokens.Add(Constants.Space); tokens.Add(new SyntaxToken("Operator", SyntaxTokens.Keyword)); tokens.Add(Constants.Space); tokens.AddRange(FormatName(syntax)); if (syntax.Method.IsGeneric) { tokens.Add(new SyntaxToken("<", SyntaxTokens.Text)); List <GenericTypeRef> genericTypes = syntax.GetGenericParameters(); for (int i = 0; i < genericTypes.Count; i++) { if (i != 0) { tokens.Add(new SyntaxToken(", ", SyntaxTokens.Text)); } tokens.Add(FormatTypeName(genericTypes[i])); } tokens.Add(new SyntaxToken(">", SyntaxTokens.Text)); } tokens.AddRange(FormatParameters(syntax)); tokens.Add(Constants.Space); tokens.Add(Constants.KeywordAs); tokens.Add(Constants.Space); tokens.AddRange(FormatReturnType(syntax)); return(tokens); }
public List <SyntaxToken> FormatReturnType(OperatorSyntax syntax) { string identifier = syntax.GetIdentifier(); List <SyntaxToken> tokens = new List <SyntaxToken>(); if (identifier == "op_Explicit") { tokens.Add(Constants.KeywordExplicit); } else if (identifier == "op_Implicit") { tokens.Add(Constants.KeywordImplicit); } else { tokens.AddRange(this.FormatTypeDetails(syntax.GetReturnType())); } return(tokens); }
public SyntaxTokenCollection Format(OperatorSyntax syntax) { SyntaxTokenCollection tokens = new SyntaxTokenCollection(); SyntaxToken inheritanceModifier = FormatInheritance(syntax); tokens.AddRange(FormatVisibility(syntax)); if (inheritanceModifier != null) { tokens.Add(Constants.Space); tokens.Add(inheritanceModifier); } tokens.Add(Constants.Space); tokens.AddRange(FormatReturnType(syntax)); tokens.Add(Constants.Space); tokens.Add(Constants.KeywordOperator); tokens.Add(Constants.Space); tokens.AddRange(FormatName(syntax)); if (syntax.Method.IsGeneric) { tokens.Add(Constants.GenericStart); List <GenericTypeRef> genericTypes = syntax.GetGenericParameters(); for (int i = 0; i < genericTypes.Count; i++) { if (i != 0) { tokens.Add(new SyntaxToken(", ", SyntaxTokens.Text)); } tokens.Add(FormatTypeName(genericTypes[i])); } tokens.Add(Constants.GenericEnd); } tokens.AddRange(FormatParameters(syntax)); return(tokens); }
public List <SyntaxToken> FormatName(OperatorSyntax syntax) { string representation = string.Empty; switch (syntax.GetIdentifier()) { // Equality overloads case "op_Equality": representation = "=="; break; case "op_Inequality": representation = "!="; break; case "op_GreaterThan": representation = ">"; break; case "op_LessThan": representation = "<"; break; case "op_GreaterThanOrEqual": representation = ">="; break; case "op_LessThanOrEqual": representation = "<="; break; // Unary overloads case "op_UnaryPlus": representation = "+"; break; case "op_UnaryNegation": representation = "-"; break; case "op_LogicalNot": representation = "!"; break; case "op_OnesComplement": representation = "~"; break; case "op_Increment": representation = "++"; break; case "op_Decrement": representation = "--"; break; case "op_True": representation = "true"; break; case "op_False": representation = "false"; break; // Binary Overloads case "op_Addition": representation = "+"; break; case "op_Subtraction": representation = "-"; break; case "op_Multiply": representation = "*"; break; case "op_Division": representation = "/"; break; case "op_Modulus": representation = "%"; break; case "op_BitwiseAnd": representation = "&"; break; case "op_BitwiseOr": representation = "|"; break; case "op_ExclusiveOr": representation = "^"; break; case "op_LeftShift": representation = "<<"; break; case "op_RightShift": representation = ">>"; break; // Concatenation operator is & in a visual basic library - cant be overloaded in C# case "op_Concatenate": representation = "+"; break; case "op_Implicit": return(this.FormatTypeDetails(syntax.GetReturnType())); case "op_Explicit": return(this.FormatTypeDetails(syntax.GetReturnType())); default: throw new NotImplementedException( "Formatting not implemented for operator '" + syntax.GetIdentifier() + "'." ); } return(new List <SyntaxToken>() { new SyntaxToken(representation, SyntaxTokens.Text) }); }
public SyntaxToken FormatInheritance(OperatorSyntax syntax) { return(FormatInheritance(syntax.GetInheritance())); }
public List <SyntaxToken> FormatVisibility(OperatorSyntax syntax) { return(FormatVisibility(syntax.GetVisibility())); }
public CSharpOperatorFormatter(OperatorSyntax syntax) { _syntax = syntax; _signiture = syntax.Method.Signiture; }
public List <SyntaxToken> FormatReturnType(OperatorSyntax syntax) { return(FormatTypeDetails(syntax.GetReturnType())); }