projects/dil: trunk/src/dil/Expressions.d comparison

comparison trunk/src/dil/Expressions.d @ 489:a7291d3ee9d7

Refactored classes that inherit from Node. Added methods addChild(), addOptChild(), addChildren(), addOptChildren() to class Node. Refactored subclasses to use the new methods instead of appending directly to the array Node.children. Moved enums StorageClass and Protection to new module dil.Enums. Added members stc, prot, isStatic() and isPulic() to Declaration.

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Mon, 03 Dec 2007 22:44:27 +0100
parents	cfb3805768b6
children	47be6bfe39cd

comparison

equal deleted inserted replaced

-:cfb3805768b6
+:a7291d3ee9d7
 {
 Expression left, right;
 Token* tok;
 this(Expression left, Expression right, Token* tok)
 {
-this.children = [left, right];
+addChildren([left, right]);
 this.left = left;
 this.right = right;
 this.tok = tok;
 }
 }
 Expression condition;
 this(Expression condition, Expression left, Expression right, Token* tok)
 {
 super(left, right, tok);
 mixin(set_kind);
-this.children ~= [condition];
+addChild(condition);
 this.condition = condition;
 }
 }
 class CommaExpression : BinaryExpression
 abstract class UnaryExpression : Expression
 {
 Expression e;
 this(Expression e)
 {
-this.children ~= e;
+addChild(e);
 this.e = e;
 }
 }
 class AddressExpression : UnaryExpression
 DotListExpression dotList;
 this(Expression e, DotListExpression dotList)
 {
 super(e);
 mixin(set_kind);
-this.children ~= [dotList];
+addChild(dotList);
 this.dotList = dotList;
 }
 }
 class CallExpression : UnaryExpression
 Expression[] args;
 this(Expression e, Expression[] args)
 {
 super(e);
 mixin(set_kind);
-this.children ~= args;
+addOptChildren(args);
 this.args = args;
 }
 }
 class NewExpression : /*Unary*/Expression
 Expression[] ctorArgs;
 this(/*Expression e, */Expression[] newArgs, Type type, Expression[] ctorArgs)
 {
 /*super(e);*/
 mixin(set_kind);
-if (newArgs.length)
+addOptChildren(newArgs);
-this.children ~= newArgs;
+addChild(type);
-this.children ~= type;
+addOptChildren(ctorArgs);
-if (ctorArgs.length)
-this.children ~= ctorArgs;
 this.newArgs = newArgs;
 this.type = type;
 this.ctorArgs = ctorArgs;
 }
 }
 Declarations decls;
 this(/*Expression e, */Expression[] newArgs, BaseClass[] bases, Expression[] ctorArgs, Declarations decls)
 {
 /*super(e);*/
 mixin(set_kind);
-if (newArgs.length)
+addOptChildren(newArgs);
-this.children ~= newArgs;
+addOptChildren(bases);
-if (bases.length)
+addOptChildren(ctorArgs);
-this.children ~= bases;
+addChild(decls);
-if (ctorArgs.length)
-this.children ~= ctorArgs;
-this.children ~= decls;
 this.newArgs = newArgs;
 this.bases = bases;
 this.ctorArgs = ctorArgs;
 this.decls = decls;
 class CastExpression : UnaryExpression
 {
 Type type;
 this(Expression e, Type type)
 {
-this.children = [type];
+addChild(type); // Add type before super().
 super(e);
 mixin(set_kind);
 this.type = type;
 }
 }
 Expression[] args;
 this(Expression e, Expression[] args)
 {
 super(e);
 mixin(set_kind);
-this.children ~= args;
+addChildren(args);
 this.args = args;
 }
 }
 class SliceExpression : UnaryExpression
 Expression left, right;
 this(Expression e, Expression left, Expression right)
 {
 super(e);
 mixin(set_kind);
+assert(left ? (right !is null) : right is null);
 if (left)
-this.children ~= left;
+addChildren([left, right]);
-if (right)
-this.children ~= right;
 this.left = left;
 this.right = right;
 }
 }
 {
 Expression[] items;
 this(Expression[] items)
 {
 mixin(set_kind);
-this.children = items;
+addChildren(items);
 this.items = items;
 }
 }
 class TemplateInstanceExpression : Expression
 Token* ident;
 TemplateArguments targs;
 this(Token* ident, TemplateArguments targs)
 {
 mixin(set_kind);
-if (targs)
+addOptChild(targs);
-this.children = [targs];
 this.ident = ident;
 this.targs = targs;
 }
 }
 {
 Expression[] values;
 this(Expression[] values)
 {
 mixin(set_kind);
-this.children = values;
+addOptChildren(values);
 this.values = values;
 }
 }
 class AArrayLiteralExpression : Expression
 this(Expression[] keys, Expression[] values)
 {
 assert(keys.length == values.length);
 mixin(set_kind);
 foreach (i, key; keys)
-this.children ~= [key, values[i]];
+addChildren([key, values[i]]);
 this.keys = keys;
 this.values = values;
 }
 }
 {
 Expression expr, msg;
 this(Expression expr, Expression msg)
 {
 mixin(set_kind);
-this.children = [expr];
+addChild(expr);
-if (msg)
+addOptChild(msg);
-this.children ~= msg;
 this.expr = expr;
 this.msg = msg;
 }
 }
 {
 Expression expr;
 this(Expression expr)
 {
 mixin(set_kind);
-this.children = [expr];
+addChild(expr);
 this.expr = expr;
 }
 }
 class ImportExpression : Expression
 {
 Expression expr;
 this(Expression expr)
 {
 mixin(set_kind);
-this.children = [expr];
+addChild(expr);
 this.expr = expr;
 }
 }
 class TypeofExpression : Expression
 {
 Type type;
 this(Type type)
 {
 mixin(set_kind);
-this.children = [type];
+addChild(type);
 this.type = type;
 }
 }
 class TypeDotIdExpression : Expression
 Type type;
 Token* ident;
 this(Type type, Token* ident)
 {
 mixin(set_kind);
-this.children = [type];
+addChild(type);
 this.type = type;
 this.ident = ident;
 }
 }
 {
 Type type;
 this(Type type)
 {
 mixin(set_kind);
-this.children = [type];
+addChild(type);
 this.type = type;
 }
 }
 class IsExpression : Expression
 Type specType;
 TemplateParameters tparams; // D 2.0
 this(Type type, Token* ident, Token* opTok, Token* specTok, Type specType, typeof(tparams) tparams)
 {
 mixin(set_kind);
-this.children = [type];
+addChild(type);
-if (specType)
+addOptChild(specType);
-this.children ~= specType;
+version(D2)
-if (tparams)
+addOptChild(tparams);
-this.children ~= tparams;
 this.type = type;
 this.ident = ident;
 this.opTok = opTok;
 this.specTok = specTok;
 this.specType = specType;
 FunctionBody funcBody;
 this()
 {
 mixin(set_kind);
-if (returnType)
+addOptChild(returnType);
-this.children ~= returnType;
+addOptChild(parameters);
-if (parameters)
+addChild(funcBody);
-this.children ~= parameters;
-this.children ~= funcBody;
 }
 this(Type returnType, Parameters parameters, FunctionBody funcBody)
 {
 this.returnType = returnType;
 Token* ident;
 TemplateArguments targs;
 this(typeof(ident) ident, typeof(targs) targs)
 {
 mixin(set_kind);
-if (targs)
+addOptChild(targs);
-this.children = [targs];
 this.ident = ident;
 this.targs = targs;
 }
 }
 }
 {
 assert(keys.length == values.length);
 mixin(set_kind);
 foreach (i, key; keys)
 {
-if (key)
+addOptChild(key); // The key is optional in ArrayInitializers.
-this.children ~= key;
+addChild(values[i]);
-if (values[i])
-this.children ~= values[i];
 }
 this.keys = keys;
 this.values = values;
 }
 }
 Token*[] idents;
 Expression[] values;
 this(Token*[] idents, Expression[] values)
 {
 mixin(set_kind);
-this.children = values;
+addOptChildren(values);
 this.idents = idents;
 this.values = values;
 }
 }
 {
 Expression e;
 this(Expression e)
 {
 mixin(set_kind);
-this.children = [e];
+addChild(e);
 this.e = e;
 }
 }
 class AsmLocalSizeExpression : Expression

Mercurial > projects > dil

comparison trunk/src/dil/Expressions.d @ 489:a7291d3ee9d7