And some more C++ header fixes

dmd/aggregate.h

@@ -191,7 +191,7 @@ class StructDeclaration : public AggregateDeclaration
     Dsymbol *search(const Loc &, Identifier *ident, int flags = SearchLocalsOnly);
     const char *kind() const;
     void finalizeSize();
-    bool fit(Loc loc, Scope *sc, Expressions *elements, Type *stype);
+    bool fit(const Loc &loc, Scope *sc, Expressions *elements, Type *stype);
     bool isPOD();
 
     StructDeclaration *isStructDeclaration() { return this; }

dmd/attrib.h

@@ -125,7 +125,7 @@ class AlignDeclaration : public AttribDeclaration
     Expression *ealign;
     structalign_t salign;
 
-    AlignDeclaration(Loc loc, Expression *ealign, Dsymbols *decl);
+    AlignDeclaration(const Loc &loc, Expression *ealign, Dsymbols *decl);
     Dsymbol *syntaxCopy(Dsymbol *s);
     Scope *newScope(Scope *sc);
     void accept(Visitor *v) { v->visit(this); }

dmd/ctfe.h

@@ -138,11 +138,11 @@ Expression *resolveSlice(Expression *e);
 uinteger_t resolveArrayLength(Expression *e);
 
 /// Create an array literal consisting of 'elem' duplicated 'dim' times.
-ArrayLiteralExp *createBlockDuplicatedArrayLiteral(Loc loc, Type *type,
+ArrayLiteralExp *createBlockDuplicatedArrayLiteral(const Loc &loc, Type *type,
         Expression *elem, size_t dim);
 
 /// Create a string literal consisting of 'value' duplicated 'dim' times.
-StringExp *createBlockDuplicatedStringLiteral(Loc loc, Type *type,
+StringExp *createBlockDuplicatedStringLiteral(const Loc &loc, Type *type,
         unsigned value, size_t dim, unsigned char sz);
 
 
@@ -158,13 +158,13 @@ void assignInPlace(Expression *dest, Expression *src);
 Expression * modifyStructField(Type *type, StructLiteralExp *se, size_t offset, Expression *newval);
 
 /// Given an AA literal aae,  set arr[index] = newval and return the new array.
-Expression *assignAssocArrayElement(Loc loc, AssocArrayLiteralExp *aae,
+Expression *assignAssocArrayElement(const Loc &loc, AssocArrayLiteralExp *aae,
     Expression *index, Expression *newval);
 
 /// Given array literal oldval of type ArrayLiteralExp or StringExp, of length
 /// oldlen, change its length to newlen. If the newlen is longer than oldlen,
 /// all new elements will be set to the default initializer for the element type.
-UnionExp changeArrayLiteralLength(Loc loc, TypeArray *arrayType,
+UnionExp changeArrayLiteralLength(const Loc &loc, TypeArray *arrayType,
     Expression *oldval,  size_t oldlen, size_t newlen);
 
 
@@ -188,15 +188,15 @@ Expression *getAggregateFromPointer(Expression *e, dinteger_t *ofs);
 bool pointToSameMemoryBlock(Expression *agg1, Expression *agg2);
 
 // return e1 - e2 as an integer, or error if not possible
-UnionExp pointerDifference(Loc loc, Type *type, Expression *e1, Expression *e2);
+UnionExp pointerDifference(const Loc &loc, Type *type, Expression *e1, Expression *e2);
 
 /// Return 1 if true, 0 if false
 /// -1 if comparison is illegal because they point to non-comparable memory blocks
-int comparePointers(Loc loc, TOK op, Type *type, Expression *agg1, dinteger_t ofs1, Expression *agg2, dinteger_t ofs2);
+int comparePointers(const Loc &loc, TOK op, Type *type, Expression *agg1, dinteger_t ofs1, Expression *agg2, dinteger_t ofs2);
 
 // Return eptr op e2, where eptr is a pointer, e2 is an integer,
 // and op is TOKadd or TOKmin
-UnionExp pointerArithmetic(Loc loc, TOK op, Type *type,
+UnionExp pointerArithmetic(const Loc &loc, TOK op, Type *type,
     Expression *eptr, Expression *e2);
 
 // True if conversion from type 'from' to 'to' involves a reinterpret_cast
@@ -216,7 +216,7 @@ TypeAArray *toBuiltinAAType(Type *t);
  *  Return ae[e2] if present, or NULL if not found.
  *  Return TOKcantexp on error.
  */
-Expression *findKeyInAA(Loc loc, AssocArrayLiteralExp *ae, Expression *e2);
+Expression *findKeyInAA(const Loc &loc, AssocArrayLiteralExp *ae, Expression *e2);
 
 /// True if type is TypeInfo_Class
 bool isTypeInfo_Class(Type *type);
@@ -231,10 +231,10 @@ bool isTypeInfo_Class(Type *type);
 bool isCtfeComparable(Expression *e);
 
 /// Evaluate ==, !=.  Resolves slices before comparing. Returns 0 or 1
-int ctfeEqual(Loc loc, TOK op, Expression *e1, Expression *e2);
+int ctfeEqual(const Loc &loc, TOK op, Expression *e1, Expression *e2);
 
 /// Evaluate is, !is.  Resolves slices before comparing. Returns 0 or 1
-int ctfeIdentity(Loc loc, TOK op, Expression *e1, Expression *e2);
+int ctfeIdentity(const Loc &loc, TOK op, Expression *e1, Expression *e2);
 
 /// Returns rawCmp OP 0; where OP is ==, !=, <, >=, etc. Result is 0 or 1
 int specificCmp(TOK op, int rawCmp);
@@ -249,17 +249,17 @@ int intSignedCmp(TOK op, sinteger_t n1, sinteger_t n2);
 int realCmp(TOK op, real_t r1, real_t r2);
 
 /// Evaluate >,<=, etc. Resolves slices before comparing. Returns 0 or 1
-int ctfeCmp(Loc loc, TOK op, Expression *e1, Expression *e2);
+int ctfeCmp(const Loc &loc, TOK op, Expression *e1, Expression *e2);
 
 /// Returns e1 ~ e2. Resolves slices before concatenation.
-UnionExp ctfeCat(Loc loc, Type *type, Expression *e1, Expression *e2);
+UnionExp ctfeCat(const Loc &loc, Type *type, Expression *e1, Expression *e2);
 
 /// Same as for constfold.Index, except that it only works for static arrays,
 /// dynamic arrays, and strings.
-Expression *ctfeIndex(Loc loc, Type *type, Expression *e1, uinteger_t indx);
+Expression *ctfeIndex(const Loc &loc, Type *type, Expression *e1, uinteger_t indx);
 
 /// Cast 'e' of type 'type' to type 'to'.
-Expression *ctfeCast(Loc loc, Type *type, Type *to, Expression *e);
+Expression *ctfeCast(const Loc &loc, Type *type, Type *to, Expression *e);
 
 
 #endif /* DMD_CTFE_H */

dmd/declaration.h

@@ -603,11 +603,11 @@ class FuncDeclaration : public Declaration
 
     unsigned flags;                     // FUNCFLAGxxxxx
 
-    static FuncDeclaration *create(Loc loc, Loc endloc, Identifier *id, StorageClass storage_class, Type *type);
+    static FuncDeclaration *create(const Loc &loc, const Loc &endloc, Identifier *id, StorageClass storage_class, Type *type);
     Dsymbol *syntaxCopy(Dsymbol *);
     bool functionSemantic();
     bool functionSemantic3();
-    bool checkForwardRef(Loc loc);
+    bool checkForwardRef(const Loc &loc);
     // called from semantic3
     VarDeclaration *declareThis(Scope *sc, AggregateDeclaration *ad);
     bool equals(RootObject *o);
@@ -617,12 +617,12 @@ class FuncDeclaration : public Declaration
     BaseClass *overrideInterface();
     bool overloadInsert(Dsymbol *s);
     FuncDeclaration *overloadExactMatch(Type *t);
-    FuncDeclaration *overloadModMatch(Loc loc, Type *tthis, bool &hasOverloads);
+    FuncDeclaration *overloadModMatch(const Loc &loc, Type *tthis, bool &hasOverloads);
     TemplateDeclaration *findTemplateDeclRoot();
     bool inUnittest();
     MATCH leastAsSpecialized(FuncDeclaration *g);
     LabelDsymbol *searchLabel(Identifier *ident);
-    int getLevel(Loc loc, Scope *sc, FuncDeclaration *fd); // lexical nesting level difference
+    int getLevel(const Loc &loc, Scope *sc, FuncDeclaration *fd); // lexical nesting level difference
     const char *toPrettyChars(bool QualifyTypes = false);
     const char *toFullSignature();  // for diagnostics, e.g. 'int foo(int x, int y) pure'
     bool isMain() const;
@@ -646,7 +646,7 @@ class FuncDeclaration : public Declaration
     bool isNogcBypassingInference();
     bool setGC();
 
-    void printGCUsage(Loc loc, const char *warn);
+    void printGCUsage(const Loc &loc, const char *warn);
     bool isolateReturn();
     bool parametersIntersect(Type *t);
     virtual bool isNested();
@@ -683,7 +683,7 @@ class FuncDeclaration : public Declaration
     void accept(Visitor *v) { v->visit(this); }
 };
 
-FuncDeclaration *resolveFuncCall(Loc loc, Scope *sc, Dsymbol *s,
+FuncDeclaration *resolveFuncCall(const Loc &loc, Scope *sc, Dsymbol *s,
         Objects *tiargs,
         Type *tthis,
         Expressions *arguments,

dmd/enum.h

@@ -57,9 +57,9 @@ class EnumDeclaration : public ScopeDsymbol
     Dsymbol *search(const Loc &, Identifier *ident, int flags = SearchLocalsOnly);
     bool isDeprecated();                // is Dsymbol deprecated?
     Prot prot();
-    Expression *getMaxMinValue(Loc loc, Identifier *id);
+    Expression *getMaxMinValue(const Loc &loc, Identifier *id);
     Expression *getDefaultValue(const Loc &loc);
-    Type *getMemtype(Loc loc);
+    Type *getMemtype(const Loc &loc);
 
     EnumDeclaration *isEnumDeclaration() { return this; }
 
@@ -88,7 +88,7 @@ class EnumMember : public VarDeclaration
 
     Dsymbol *syntaxCopy(Dsymbol *s);
     const char *kind() const;
-    Expression *getVarExp(Loc loc, Scope *sc);
+    Expression *getVarExp(const Loc &loc, Scope *sc);
 
     EnumMember *isEnumMember() { return this; }
     void accept(Visitor *v) { v->visit(this); }

dmd/expression.h

@@ -71,7 +71,7 @@ Expression *resolveProperties(Scope *sc, Expression *e);
 Expression *resolvePropertiesOnly(Scope *sc, Expression *e1);
 bool checkAccess(Loc loc, Scope *sc, Expression *e, Declaration *d);
 bool checkAccess(Loc loc, Scope *sc, Package *p);
-Expression *build_overload(Loc loc, Scope *sc, Expression *ethis, Expression *earg, Dsymbol *d);
+Expression *build_overload(const Loc &loc, Scope *sc, Expression *ethis, Expression *earg, Dsymbol *d);
 Dsymbol *search_function(ScopeDsymbol *ad, Identifier *funcid);
 void expandTuples(Expressions *exps);
 TupleDeclaration *isAliasThisTuple(Expression *e);
@@ -184,7 +184,7 @@ class Expression : public RootObject
     {
         return ::castTo(this, sc, t);
     }
-    virtual Expression *resolveLoc(Loc loc, Scope *sc);
+    virtual Expression *resolveLoc(const Loc &loc, Scope *sc);
     virtual bool checkType();
     virtual bool checkValue();
     bool checkScalar();
@@ -503,7 +503,7 @@ class StructLiteralExp : public Expression
 };
 
 class DotIdExp;
-DotIdExp *typeDotIdExp(Loc loc, Type *type, Identifier *ident);
+DotIdExp *typeDotIdExp(const Loc &loc, Type *type, Identifier *ident);
 
 class TypeExp : public Expression
 {
@@ -714,13 +714,13 @@ class UnaExp : public Expression
 
     Expression *syntaxCopy();
     Expression *incompatibleTypes();
-    Expression *resolveLoc(Loc loc, Scope *sc);
+    Expression *resolveLoc(const Loc &loc, Scope *sc);
 
     void accept(Visitor *v) { v->visit(this); }
 };
 
-typedef UnionExp (*fp_t)(Loc loc, Type *, Expression *, Expression *);
-typedef int (*fp2_t)(Loc loc, TOK, Expression *, Expression *);
+typedef UnionExp (*fp_t)(const Loc &loc, Type *, Expression *, Expression *);
+typedef int (*fp2_t)(const Loc &loc, TOK, Expression *, Expression *);
 
 class BinExp : public Expression
 {
@@ -1335,35 +1335,35 @@ class DefaultInitExp : public Expression
 class FileInitExp : public DefaultInitExp
 {
 public:
-    Expression *resolveLoc(Loc loc, Scope *sc);
+    Expression *resolveLoc(const Loc &loc, Scope *sc);
     void accept(Visitor *v) { v->visit(this); }
 };
 
 class LineInitExp : public DefaultInitExp
 {
 public:
-    Expression *resolveLoc(Loc loc, Scope *sc);
+    Expression *resolveLoc(const Loc &loc, Scope *sc);
     void accept(Visitor *v) { v->visit(this); }
 };
 
 class ModuleInitExp : public DefaultInitExp
 {
 public:
-    Expression *resolveLoc(Loc loc, Scope *sc);
+    Expression *resolveLoc(const Loc &loc, Scope *sc);
     void accept(Visitor *v) { v->visit(this); }
 };
 
 class FuncInitExp : public DefaultInitExp
 {
 public:
-    Expression *resolveLoc(Loc loc, Scope *sc);
+    Expression *resolveLoc(const Loc &loc, Scope *sc);
     void accept(Visitor *v) { v->visit(this); }
 };
 
 class PrettyFuncInitExp : public DefaultInitExp
 {
 public:
-    Expression *resolveLoc(Loc loc, Scope *sc);
+    Expression *resolveLoc(const Loc &loc, Scope *sc);
     void accept(Visitor *v) { v->visit(this); }
 };
 
@@ -1429,24 +1429,24 @@ UnionExp Cast(Loc loc, Type *type, Type *to, Expression *e1);
 UnionExp ArrayLength(Type *type, Expression *e1);
 UnionExp Ptr(Type *type, Expression *e1);
 
-UnionExp Add(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Min(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Mul(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Div(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Mod(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Pow(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Shl(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Shr(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Ushr(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp And(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Or(Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Xor(Loc loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Add(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Min(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Mul(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Div(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Mod(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Pow(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Shl(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Shr(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Ushr(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp And(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Or(const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Xor(const Loc &loc, Type *type, Expression *e1, Expression *e2);
 UnionExp Index(Type *type, Expression *e1, Expression *e2);
 UnionExp Cat(Type *type, Expression *e1, Expression *e2);
 
-UnionExp Equal(TOK op, Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Cmp(TOK op, Loc loc, Type *type, Expression *e1, Expression *e2);
-UnionExp Identity(TOK op, Loc loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Equal(TOK op, const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Cmp(TOK op, const Loc &loc, Type *type, Expression *e1, Expression *e2);
+UnionExp Identity(TOK op, const Loc &loc, Type *type, Expression *e1, Expression *e2);
 
 UnionExp Slice(Type *type, Expression *e1, Expression *lwr, Expression *upr);