dparse.formatter

enum IndentStyle

class Formatter

fn format

Types 2

enumIndentStyle

The only brace styles worth using.

allman--- if (something) { foo(); bar(); } else { bar(); baz(); } ---

otbs--- if (something) { foo(); bar(); } else { bar(); baz(); } ---

classFormatter(Sink)

Fields

Sink sink

bool ignoreNewlines

bool useTabs

uint caseDepth

uint indentWidth

uint indentLevel

IndentStyle style

What lastThing

uint lineLength

uint maxLineLength

possibleDeclarations

Methods

void format(const AddExpression addExpression)

void format(const AliasDeclaration aliasDeclaration, const Attribute[] attrs = null)

void format(const AliasInitializer aliasInitializer)LinkageAttribute linkageAttribute; Type type; Token name; AliasInitializer[] initializers; string comment; Parameters parameters; MemberFunctionAttribute[] memberFunctionAttributes;

void format(const AliasThisDeclaration decl, const Attribute[] attrs = null)Token name; StorageClass[] storageClasses; TemplateParameters templateParameters; Type type; FunctionLiteralExpression functionLiteralExpression; Parameters parameters; MemberFunctionAttribute[] me...

void format(const AlignAttribute alignAttribute)Token identifier;

void format(const AndAndExpression andAndExpression)Token intLiteral;

void format(const AndExpression andExpression)

void format(const NamedArgument argument)

void format(const NamedArgumentList argumentList)

void format(const ArgumentList argumentList)

void format(const Arguments arguments)

void format(const ArrayInitializer arrayInitializer)

void format(const ArrayLiteral arrayLiteral)ArrayMemberInitialization[] arrayMemberInitializations;

void format(const ArrayMemberInitialization arrayMemberInitialization)ArgumentList argumentList;

void format(const AsmAddExp asmAddExp)AssignExpression assignExpression; NonVoidInitializer nonVoidInitializer;

void format(const AsmAndExp asmAndExp)

void format(const AsmBrExp asmBrExp)

void format(const AsmEqualExp asmEqualExp)

void format(const AsmExp asmExp)

void format(const AsmInstruction asmInstruction)

void format(const AsmLogAndExp asmLogAndExp)

void format(const AsmLogOrExp asmLogOrExp)

void format(const AsmMulExp asmMulExp)

void format(const AsmOrExp asmOrExp)

void format(const AsmPrimaryExp asmPrimaryExp)

void format(const AsmRelExp asmRelExp)

void format(const AsmShiftExp asmShiftExp)

void format(const AsmStatement asmStatement)

void format(const AsmTypePrefix asmTypePrefix)

void format(const AsmUnaExp asmUnaExp)

void format(const AsmXorExp asmXorExp)

void format(const AssertArguments assertArguments)

void format(const AssertExpression assertExpression)

void format(const AssignExpression assignExpression)AssertArguments assertArguments;

void format(const AssocArrayLiteral assocArrayLiteral)ExpressionNode ternaryExpression; ExpressionNode assignExpression; IdType operator;

void format(const AtAttribute atAttribute)KeyValuePairs keyValuePairs;

void format(const Attribute att)FunctionCallExpression functionCallExpression; ArgumentList argumentList; Token identifier;

void format(const AttributeDeclaration decl, const Attribute[] attrs = null)LinkageAttribute linkageAttribute; AlignAttribute alignAttribute; PragmaExpression pragmaExpression; StorageClass storageClass; IdType attribute;

void format(const AutoDeclaration decl)

void format(const BlockStatement blockStatement)StorageClasses[] storageClasses; Token[] identifiers; Initializer[] initializers;

void format(const BreakStatement breakStatement)

void format(const BaseClass baseClass)

void format(const BaseClassList baseClassList)

void format(const CaseRangeStatement caseRangeStatement)

void format(const CaseStatement caseStatement)AssignExpression low; AssignExpression high; DeclarationsAndStatements declarationsAndStatements;

void format(const CastExpression castExpression)ArgumentList argumentList; DeclarationsAndStatements declarationsAndStatements;

void format(const CastQualifier qual)Type type; CastQualifier castQualifier; UnaryExpression unaryExpression;

void format(const Catch catch_)Token first; Token second;

void format(const Catches catches)Type type; Token identifier; DeclarationOrStatement declarationOrStatement;

void format(const ClassDeclaration decl, const Attribute[] attrs = null)Catch[] catches; LastCatch lastCatch;

void format(const CmpExpression cmpExpression)Token name; TemplateParameters templateParameters; Constraint constraint; BaseClassList baseClassList; StructBody structBody; string comment;

void format(const CompileCondition compileCondition)ExpressionNode shiftExpression; ExpressionNode equalExpression; ExpressionNode identityExpression; ExpressionNode relExpression; ExpressionNode inExpression;

void format(const ConditionalDeclaration decl, const Attribute[] attrs = null)VersionCondition versionCondition; DebugCondition debugCondition; StaticIfCondition staticIfCondition;

void format(const ConditionalStatement stmnt)CompileCondition compileCondition; Declaration[] trueDeclarations; Declaration[] falseDeclaration;

void format(const Constraint constraint)CompileCondition compileCondition; DeclarationOrStatement trueStatement; DeclarationOrStatement falseStatement;

void format(const Constructor constructor, const Attribute[] attrs = null)

void format(const ContinueStatement continueStatement)Parameters parameters; FunctionBody functionBody; Constraint constraint; MemberFunctionAttribute[] memberFunctionAttributes; TemplateParameters templateParameters; size_t location; string comment;

void format(const DebugCondition debugCondition)

void format(const DebugSpecification debugSpecification)

void format(const Declaration declaration)

void format(const DeclarationOrStatement declarationsOrStatement)

void format(const DeclarationsAndStatements declarationsAndStatements)

void format(const Declarator declarator)

void format(const DefaultStatement defaultStatement)Token name; Initializer initializer;

void format(const DeleteExpression deleteExpression)DeclarationsAndStatements declarationsAndStatements;

void format(const DeleteStatement deleteStatement)

void format(const Deprecated deprecated_)

void format(const Destructor destructor, const Attribute[] attrs = null)

void format(const DoStatement doStatement)FunctionBody functionBody;

void format(const EnumBody enumBody)StatementNoCaseNoDefault statementNoCaseNoDefault; Expression expression;

void format(const EnumDeclaration enumDeclaration, const Attribute[] attrs = null)

void format(const EnumMember enumMember)Token name; Type type; EnumBody enumBody; string comment;

void format(const EnumMemberAttribute ema)Token name; Type type; AssignExpression assignExpression; string comment;

void format(const EponymousTemplateDeclaration decl)

void format(const EqualExpression equalExpression)Token name; TemplateParameters templateParameters; AssignExpression assignExpression;

void format(const Expression expression)

void format(const ExpressionNode n)

void format(const ExpressionStatement expressionStatement)

void format(const FinalSwitchStatement finalSwitchStatement)

void format(const Finally finally_)

void format(const ForStatement forStatement)

void format(const ForeachStatement foreachStatement)DeclarationOrStatement initialization; ExpressionStatement test; Expression increment; DeclarationOrStatement declarationOrStatement;

void format(const ForeachType foreachType)IdType type; ForeachTypeList foreachTypeList; ForeachType foreachType; Expression low; Expression high; DeclarationOrStatement declarationOrStatement; size_t startIndex;

void format(const ForeachTypeList foreachTypeList)IdType[] typeConstructors; Type type; Token identifier;

void format(const FunctionAttribute functionAttribute)ForeachType[] items;

void format(const FunctionBody functionBody)Token token; AtAttribute atAttribute;

void format(const FunctionCallExpression functionCallExpression)

void format(const FunctionContract functionContract)Type type; UnaryExpression unaryExpression; TemplateArguments templateArguments; Arguments arguments;

void format(const FunctionDeclaration decl, const Attribute[] attrs = null)InOutContractExpression inOutContractExpression; InOutStatement inOutStatement;

void format(const FunctionLiteralExpression functionLiteralExpression)bool hasAuto; bool hasRef;

void format(const GotoStatement gotoStatement)

void format(const IdentifierChain identifierChain)

void format(const DeclaratorIdentifierList declaratorIdentifierList)

void format(const TypeIdentifierPart typeIdentifierPart)

void format(const IdentifierOrTemplateChain identifierOrTemplateChain)

void format(const IdentifierOrTemplateInstance identifierOrTemplateInstance)

void format(const IdentityExpression identityExpression)

void format(const IfStatement ifStatement)

void format(const IfCondition ifCondition)IdType[] typeCtors; Type type; Token identifier; Expression expression; DeclarationOrStatement thenStatement; DeclarationOrStatement elseStatement;

void format(const ImportBind importBind)

void format(const ImportBindings importBindings)

void format(const ImportDeclaration importDeclaration, const Attribute[] attrs = null)SingleImport singleImport; ImportBind[] importBinds;

void format(const ImportExpression importExpression)SingleImport[] singleImports; ImportBindings importBindings;

void format(const Index index)

void format(const IndexExpression indexExpression)

void format(const InContractExpression expression)UnaryExpression unaryExpression; ArgumentList argumentList;

void format(const InExpression inExpression)

void format(const InOutContractExpression inOutContractExpression)

void format(const InOutStatement inOutStatement)

void format(const InStatement inStatement)

void format(const Initialize initialize)

void format(const Initializer initializer)

void format(const InterfaceDeclaration interfaceDeclaration, const Attribute[] attrs = null)

void format(const InterpolatedString interpolatedString)Token name; TemplateParameters templateParameters; Constraint constraint; BaseClassList baseClassList; StructBody structBody; string comment;

void format(const InterpolatedStringText interpolatedStringText)

void format(const InterpolatedStringExpression interpolatedStringExpression)

void format(const Invariant invariant_, const Attribute[] attrs = null)

void format(const IsExpression isExpression)BlockStatement blockStatement; string comment;

void format(const KeyValuePair keyValuePair)Type type; Token identifier; TypeSpecialization typeSpecialization; TemplateParameterList templateParameterList; IdType equalsOrColon;

void format(const KeyValuePairs keyValuePairs)AssignExpression key; AssignExpression value;

void format(const LabeledStatement stmt)KeyValuePair[] keyValuePairs;

void format(const LastCatch lastCatch)Token identifier; DeclarationOrStatement declarationOrStatement;

void format(const LinkageAttribute linkageAttribute)

void format(const MemberFunctionAttribute memberFunctionAttribute)Token identifier; bool hasPlusPlus; IdentifierChain identifierChain;

void format(const MissingFunctionBody missingFunctionBody)IdType tokenType; AtAttribute atAttribute;

void format(const MixinDeclaration mixinDeclaration, const Attribute[] attrs = null)

void format(const MixinExpression mixinExpression)MixinExpression mixinExpression; TemplateMixinExpression templateMixinExpression;

void format(const MixinTemplateDeclaration mixinTemplateDeclaration, const Attribute[] attrs = null)

void format(const MixinTemplateName mixinTemplateName)

void format(const Module module_)Symbol symbol; IdentifierOrTemplateChain identifierOrTemplateChain; TypeofExpression typeofExpression;

void format(const ModuleDeclaration moduleDeclaration)ModuleDeclaration moduleDeclaration; Declaration[] declarations;

void format(const MulExpression mulExpression)IdentifierChain moduleName;

void format(const NewAnonClassExpression newAnonClassExpression)

void format(const NewExpression newExpression)Arguments allocatorArguments; Arguments constructorArguments; BaseClassList baseClassList; StructBody structBody;

void format(const NonVoidInitializer nonVoidInitializer)Type type; NewAnonClassExpression newAnonClassExpression; Arguments arguments; AssignExpression assignExpression;

void format(const Operands operands)AssignExpression assignExpression; ArrayInitializer arrayInitializer; StructInitializer structInitializer;

void format(const OrExpression orExpression)

void format(const OrOrExpression orOrExpression)

void format(const OutContractExpression expression)

void format(const OutStatement stmnt)

void format(const ParameterAttribute pa)Token parameter; BlockStatement blockStatement;

void format(const Parameter parameter)

void format(const Parameters parameters)ParameterAttribute[] parameterAttributes; Type type; Token name; bool vararg; AssignExpression default_; TypeSuffix[] cstyle;

void format(const Postblit postblit, const Attribute[] attrs = null)Parameter[] parameters; bool hasVarargs;

void format(const PowExpression powExpression)FunctionBody functionBody;

void format(const PragmaDeclaration pragmaDeclaration, const Attribute[] attrs = null)

void format(const PragmaExpression pragmaExpression)PragmaExpression pragmaExpression;

void format(const PrimaryExpression primaryExpression)Token identifier; ArgumentList argumentList;

void format(const Register register)Token dot; Token primary; IdentifierOrTemplateInstance identifierOrTemplateInstance; Token basicType; TypeofExpression typeofExpression; TypeidExpression typeidExpression; ArrayLiteral arrayLiteral...

void format(const RelExpression relExpression)

void format(const ReturnStatement returnStatement)

void format(const ScopeGuardStatement scopeGuardStatement)

void format(const SharedStaticConstructor sharedStaticConstructor, const Attribute[] attrs = null)Token identifier; DeclarationOrStatement declarationOrStatement;

void format(const SharedStaticDestructor sharedStaticDestructor, const Attribute[] attrs = null)

void format(const ShiftExpression shiftExpression)

void format(const ShortenedFunctionBody shortenedFunctionBody)

void format(const SingleImport singleImport)

void format(const SpecifiedFunctionBody specifiedFunctionBody)Token rename; IdentifierChain identifierChain;

void format(const Statement statement)

void format(const StatementNoCaseNoDefault statementNoCaseNoDefault)StatementNoCaseNoDefault statementNoCaseNoDefault; CaseStatement caseStatement; CaseRangeStatement caseRangeStatement; DefaultStatement defaultStatement;

void format(const StaticAssertDeclaration staticAssertDeclaration, const Attribute[] attrs = null)

void format(const StaticAssertStatement staticAssertStatement)

void format(const StaticConstructor staticConstructor, const Attribute[] attrs = null)

void format(const StaticDestructor staticDestructor, const Attribute[] attrs = null)

void format(const StaticIfCondition staticIfCondition)

void format(const StorageClass storageClass)

void format(const StructBody structBody)AtAttribute atAttribute; Deprecated deprecated_; LinkageAttribute linkageAttribute; Token token;

void format(const StructDeclaration decl, const Attribute[] attrs = null)

void format(const StructInitializer structInitializer)Token name; TemplateParameters templateParameters; Constraint constraint; StructBody structBody; string comment;

void format(const StructMemberInitializer structMemberInitializer)

void format(const StructMemberInitializers structMemberInitializers)Token identifier; NonVoidInitializer nonVoidInitializer;

void format(const SwitchStatement switchStatement, bool isFinal = false)

void format(const Symbol symbol)

void format(const SynchronizedStatement synchronizedStatement)

void format(const TemplateAliasParameter templateAliasParameter)Expression expression; StatementNoCaseNoDefault statementNoCaseNoDefault;

void format(const NamedTemplateArgument namedTemplateArgument)Type type; Token identifier; Type colonType; AssignExpression colonExpression; Type assignType; AssignExpression assignExpression;

void format(const TemplateArgument templateArgument)

void format(const NamedTemplateArgumentList namedTemplateArgumentList, bool parens = true)Type type; AssignExpression assignExpression;

void format(const TemplateArgumentList templateArgumentList, bool parens = true)

void format(const TemplateArguments templateArguments)

void format(const TemplateDeclaration templateDeclaration, const Attribute[] attrs = null)TemplateArgumentList templateArgumentList; TemplateSingleArgument templateSingleArgument;

void format(const TemplateInstance templateInstance)Token name; TemplateParameters templateParameters; Constraint constraint; Declaration[] declarations; EponymousTemplateDeclaration eponymousTemplateDeclaration; string comment;

void format(const TemplateMixinExpression templateMixinExpression)Token identifier; TemplateArguments templateArguments;

void format(const TemplateParameter templateParameter)Token identifier; TemplateArguments templateArguments; MixinTemplateName mixinTemplateName;

void format(const TemplateParameterList templateParameterList)

void format(const TemplateParameters templateParameters)

void format(const TemplateSingleArgument templateSingleArgument)

void format(const TemplateThisParameter templateThisParameter)Token token;

void format(const TemplateTupleParameter templateTupleParameter)

void format(const TemplateTypeParameter templateTypeParameter)

void format(const TemplateValueParameter templateValueParameter)Token identifier; Type colonType; Type assignType;

void format(const TemplateValueParameterDefault templateValueParameterDefault)Type type; Token identifier; Expression expression; TemplateValueParameterDefault templateValueParameterDefault;

void format(const TernaryExpression expr)

void format(const ThrowExpression throwExpression)ExpressionNode orOrExpression; ExpressionNode expression; ExpressionNode ternaryExpression;

void format(const Token token)

void format(const TraitsExpression traitExpr)

void format(const TryStatement tryStatement)Token identifier; TemplateArgumentList templateArgumentList;

void format(const Type type)DeclarationOrStatement declarationOrStatement; Catches catches; Finally finally_;

void format(const Type2 type2)IdType[] typeConstructors; TypeSuffix[] typeSuffixes; Type2 type2;

void format(const TypeSpecialization typeSpecialization)IdType builtinType; TypeofExpression typeofExpression; IdentifierList identifierList; IdType typeConstructor; Type type; TraitsExpression traitsExpression; MixinExpression mixinExpression;

void format(const TypeSuffix typeSuffix)Token token; Type type;

void format(const TypeidExpression idExpr)Token delegateOrFunction; bool star; bool array; Type type; AssignExpression low; AssignExpression high; Parameters parameters; MemberFunctionAttribute[] memberFunctionAttributes;

void format(const TypeofExpression typeofExpr)Type type; Expression expression;

void format(const UnaryExpression unary)Expression expression; Token return_;

void format(const UnionDeclaration decl, const Attribute[] attrs = null)Type type; PrimaryExpression primaryExpression; Token prefix; Token suffix; UnaryExpression unaryExpression; NewExpression newExpression; DeleteExpression deleteExpression; CastExpression castExpre...

void format(const Unittest unittest_, const Attribute[] attrs = null)Token name; TemplateParameters templateParameters; Constraint constraint; StructBody structBody; string comment;

void format(const VariableDeclaration decl, const Attribute[] attrs = null)BlockStatement blockStatement; string comment;

void format(const Vector vector)Type type; Declarator[] declarators; StorageClass storageClass; AutoDeclaration autoDeclaration; string comment;

void format(const VersionCondition versionCondition)

void format(const VersionSpecification ver, const Attribute[] attrs = null)

void format(const WhileStatement stmt)

void format(const WithStatement stmt)

void format(const XorExpression xorExpression)Expression expression; DeclarationsOrStatement declarationOrStatement;

void indent()

void outdent()

void putIndent()

string getIndent()

void newThing(What thing)

void lineGap(int gap)

void newlineIndent()

void newline()

void space()

string binary(string symbol, string operator = null, bool nospace = false)

void startBlock()

void endBlock()

string tokenRep(Token t)

string tokenRep(IdType t)

void putComment(string c)

void putAttrs(const Attribute[] attrs)

void put(string s)

void formatCaseDecls(const DeclarationsAndStatements declsAndStmnts)

bool needIndent(const Statement s)

bool needIndent(const Declaration d)

bool needIndent(const DeclarationOrStatement dors)

void maybeIndent(T)(const T t)

bool isEmptyDeclaration(const Declaration decl)

Constructors

this(Sink sink, bool useTabs = false, IndentStyle style = IndentStyle.allman, uint indentWidth = 4)Params: sink = the output range that the formatted source code is placed in useTabs = if true, tabs are used for indent levels instead of spaces style = the brace style indentWidth = the number of ...

Nested Templates

What

Functions 1

void format(Sink,  T)(Sink sink,  T node,  bool  useTabs =  false,
     IndentStyle style =  IndentStyle.allman,  uint  indentWith =  4)