more consistent placement of & and *, on the type (#848)

3 files changed, 111 insertions, 105 deletions

diff --git a/src/support/command-line.cpp b/src/support/command-line.cpp
index 1c80b3738..e415715c3 100644
--- a/src/support/command-line.cpp
+++ b/src/support/command-line.cpp
@@ -22,7 +22,7 @@ using namespace wasm;
 #define SCREEN_WIDTH 80
 #endif
 
-void printWrap(std::ostream& os, int leftPad, const std::string &content) {
+void printWrap(std::ostream& os, int leftPad, const std::string& content) {
   int len = content.size();
   int space = SCREEN_WIDTH - leftPad;
   std::string nextWord;
@@ -43,21 +43,21 @@ void printWrap(std::ostream& os, int leftPad, const std::string &content) {
   }
 }
 
-Options::Options(const std::string &command, const std::string &description)
+Options::Options(const std::string& command, const std::string& description)
     : debug(false), positional(Arguments::Zero) {
   add("--help", "-h", "Show this help message and exit", Arguments::Zero,
-      [this, command, description](Options *o, const std::string &) {
+      [this, command, description](Options* o, const std::string&) {
         std::cerr << command;
         if (positional != Arguments::Zero) std::cerr << ' ' << positionalName;
         std::cerr << "\n\n";
         printWrap(std::cerr, 0, description);
         std::cerr << "\n\nOptions:\n";
         size_t optionWidth = 0;
-        for (const auto &o : options) {
+        for (const auto& o : options) {
           optionWidth =
               std::max(optionWidth, o.longName.size() + o.shortName.size());
         }
-        for (const auto &o : options) {
+        for (const auto& o : options) {
           bool long_n_short = o.longName.size() != 0 && o.shortName.size() != 0;
           size_t pad = 1 + optionWidth - o.longName.size() - o.shortName.size();
           std::cerr << "  " << o.longName << (long_n_short ? ',' : ' ')
@@ -69,30 +69,30 @@ Options::Options(const std::string &command, const std::string &description)
         exit(EXIT_SUCCESS);
       });
   add("--debug", "-d", "Print debug information to stderr", Arguments::Zero,
-      [&](Options *o, const std::string &arguments) { debug = true; });
+      [&](Options* o, const std::string& arguments) { debug = true; });
 }
 
 Options::~Options() {}
 
-Options &Options::add(const std::string &longName, const std::string &shortName,
-                      const std::string &description, Arguments arguments,
-                      const Action &action) {
+Options& Options::add(const std::string& longName, const std::string& shortName,
+                      const std::string& description, Arguments arguments,
+                      const Action& action) {
   options.push_back({longName, shortName, description, arguments, action, 0});
   return *this;
 }
 
-Options &Options::add_positional(const std::string &name, Arguments arguments,
-                                 const Action &action) {
+Options& Options::add_positional(const std::string& name, Arguments arguments,
+                                 const Action& action) {
   positional = arguments;
   positionalName = name;
   positionalAction = action;
   return *this;
 }
 
-void Options::parse(int argc, const char *argv[]) {
+void Options::parse(int argc, const char* argv[]) {
   assert(argc > 0 && "expect at least program name as an argument");
   size_t positionalsSeen = 0;
-  auto dashes = [](const std::string &s) {
+  auto dashes = [](const std::string& s) {
     for (size_t i = 0;; ++i) {
       if (s[i] != '-') return i;
     }
@@ -130,8 +130,8 @@ void Options::parse(int argc, const char *argv[]) {
       argument = currentOption.substr(equal + 1);
       currentOption = currentOption.substr(0, equal);
     }
-    Option *option = nullptr;
-    for (auto &o : options)
+    Option* option = nullptr;
+    for (auto& o : options)
       if (o.longName == currentOption || o.shortName == currentOption)
         option = &o;
     if (!option) {
diff --git a/src/wasm-traversal.h b/src/wasm-traversal.h
index 620ff0161..0b8097f56 100644
--- a/src/wasm-traversal.h
+++ b/src/wasm-traversal.h
@@ -35,40 +35,40 @@ namespace wasm {
 template<typename SubType, typename ReturnType = void>
 struct Visitor {
   // Expression visitors
-  ReturnType visitBlock(Block *curr) {}
-  ReturnType visitIf(If *curr) {}
-  ReturnType visitLoop(Loop *curr) {}
-  ReturnType visitBreak(Break *curr) {}
-  ReturnType visitSwitch(Switch *curr) {}
-  ReturnType visitCall(Call *curr) {}
-  ReturnType visitCallImport(CallImport *curr) {}
-  ReturnType visitCallIndirect(CallIndirect *curr) {}
-  ReturnType visitGetLocal(GetLocal *curr) {}
-  ReturnType visitSetLocal(SetLocal *curr) {}
-  ReturnType visitGetGlobal(GetGlobal *curr) {}
-  ReturnType visitSetGlobal(SetGlobal *curr) {}
-  ReturnType visitLoad(Load *curr) {}
-  ReturnType visitStore(Store *curr) {}
-  ReturnType visitConst(Const *curr) {}
-  ReturnType visitUnary(Unary *curr) {}
-  ReturnType visitBinary(Binary *curr) {}
-  ReturnType visitSelect(Select *curr) {}
-  ReturnType visitDrop(Drop *curr) {}
-  ReturnType visitReturn(Return *curr) {}
-  ReturnType visitHost(Host *curr) {}
-  ReturnType visitNop(Nop *curr) {}
-  ReturnType visitUnreachable(Unreachable *curr) {}
+  ReturnType visitBlock(Block* curr) {}
+  ReturnType visitIf(If* curr) {}
+  ReturnType visitLoop(Loop* curr) {}
+  ReturnType visitBreak(Break* curr) {}
+  ReturnType visitSwitch(Switch* curr) {}
+  ReturnType visitCall(Call* curr) {}
+  ReturnType visitCallImport(CallImport* curr) {}
+  ReturnType visitCallIndirect(CallIndirect* curr) {}
+  ReturnType visitGetLocal(GetLocal* curr) {}
+  ReturnType visitSetLocal(SetLocal* curr) {}
+  ReturnType visitGetGlobal(GetGlobal* curr) {}
+  ReturnType visitSetGlobal(SetGlobal* curr) {}
+  ReturnType visitLoad(Load* curr) {}
+  ReturnType visitStore(Store* curr) {}
+  ReturnType visitConst(Const* curr) {}
+  ReturnType visitUnary(Unary* curr) {}
+  ReturnType visitBinary(Binary* curr) {}
+  ReturnType visitSelect(Select* curr) {}
+  ReturnType visitDrop(Drop* curr) {}
+  ReturnType visitReturn(Return* curr) {}
+  ReturnType visitHost(Host* curr) {}
+  ReturnType visitNop(Nop* curr) {}
+  ReturnType visitUnreachable(Unreachable* curr) {}
   // Module-level visitors
-  ReturnType visitFunctionType(FunctionType *curr) {}
-  ReturnType visitImport(Import *curr) {}
-  ReturnType visitExport(Export *curr) {}
-  ReturnType visitGlobal(Global *curr) {}
-  ReturnType visitFunction(Function *curr) {}
-  ReturnType visitTable(Table *curr) {}
-  ReturnType visitMemory(Memory *curr) {}
-  ReturnType visitModule(Module *curr) {}
-
-  ReturnType visit(Expression *curr) {
+  ReturnType visitFunctionType(FunctionType* curr) {}
+  ReturnType visitImport(Import* curr) {}
+  ReturnType visitExport(Export* curr) {}
+  ReturnType visitGlobal(Global* curr) {}
+  ReturnType visitFunction(Function* curr) {}
+  ReturnType visitTable(Table* curr) {}
+  ReturnType visitMemory(Memory* curr) {}
+  ReturnType visitModule(Module* curr) {}
+
+  ReturnType visit(Expression* curr) {
     assert(curr);
 
     #define DELEGATE(CLASS_TO_VISIT) \
@@ -116,29 +116,29 @@ struct UnifiedExpressionVisitor : public Visitor<SubType> {
   ReturnType visitExpression(Expression* curr) {}
 
   // redirects
-  ReturnType visitBlock(Block *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitIf(If *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitLoop(Loop *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitBreak(Break *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitSwitch(Switch *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitCall(Call *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitCallImport(CallImport *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitCallIndirect(CallIndirect *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitGetLocal(GetLocal *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitSetLocal(SetLocal *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitGetGlobal(GetGlobal *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitSetGlobal(SetGlobal *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitLoad(Load *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitStore(Store *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitConst(Const *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitUnary(Unary *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitBinary(Binary *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitSelect(Select *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitDrop(Drop *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitReturn(Return *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitHost(Host *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitNop(Nop *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
-  ReturnType visitUnreachable(Unreachable *curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitBlock(Block* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitIf(If* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitLoop(Loop* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitBreak(Break* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitSwitch(Switch* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitCall(Call* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitCallImport(CallImport* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitCallIndirect(CallIndirect* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitGetLocal(GetLocal* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitSetLocal(SetLocal* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitGetGlobal(GetGlobal* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitSetGlobal(SetGlobal* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitLoad(Load* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitStore(Store* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitConst(Const* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitUnary(Unary* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitBinary(Binary* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitSelect(Select* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitDrop(Drop* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitReturn(Return* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitHost(Host* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitNop(Nop* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
+  ReturnType visitUnreachable(Unreachable* curr) { return static_cast<SubType*>(this)->visitExpression(curr); }
 };
 
 //
@@ -156,7 +156,7 @@ struct Walker : public VisitorType {
   // Note that the visit*() for the result node is not called for you (i.e.,
   // just one visit*() method is called by the traversal; if you replace a node,
   // and you want to process the output, you must do that explicitly).
-  Expression* replaceCurrent(Expression *expression) {
+  Expression* replaceCurrent(Expression* expression) {
     return replace = expression;
   }
 
@@ -183,14 +183,14 @@ struct Walker : public VisitorType {
     walk(func->body);
   }
 
-  void walkModule(Module *module) {
+  void walkModule(Module* module) {
     setModule(module);
     static_cast<SubType*>(this)->doWalkModule(module);
     static_cast<SubType*>(this)->visitModule(module);
   }
 
   // override this to provide custom functionality
-  void doWalkModule(Module *module) {
+  void doWalkModule(Module* module) {
     // Dispatch statically through the SubType.
     SubType* self = static_cast<SubType*>(this);
     for (auto& curr : module->functionTypes) {
@@ -281,16 +281,16 @@ struct Walker : public VisitorType {
   static void doVisitNop(SubType* self, Expression** currp)          { self->visitNop((*currp)->cast<Nop>()); }
   static void doVisitUnreachable(SubType* self, Expression** currp)  { self->visitUnreachable((*currp)->cast<Unreachable>()); }
 
-  void setModule(Module *module) {
+  void setModule(Module* module) {
     currModule = module;
   }
 
-  void setFunction(Function *func) {
+  void setFunction(Function* func) {
     currFunction = func;
   }
 
 private:
-  Expression *replace = nullptr; // a node to replace
+  Expression* replace = nullptr; // a node to replace
   std::vector<Task> stack; // stack of tasks
   Function* currFunction = nullptr; // current function being processed
   Module* currModule = nullptr; // current module being processed
diff --git a/src/wasm.h b/src/wasm.h
index 44326948b..c1ef75ea9 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -74,11 +74,11 @@ namespace wasm {
 
 struct Name : public cashew::IString {
   Name() : cashew::IString() {}
-  Name(const char *str) : cashew::IString(str, false) {}
+  Name(const char* str) : cashew::IString(str, false) {}
   Name(cashew::IString str) : cashew::IString(str) {}
-  Name(const std::string &str) : cashew::IString(str.c_str(), false) {}
+  Name(const std::string& str) : cashew::IString(str.c_str(), false) {}
 
-  friend std::ostream& operator<<(std::ostream &o, Name name) {
+  friend std::ostream& operator<<(std::ostream& o, Name name) {
     assert(name.str);
     return o << '$' << name.str; // reference interpreter requires we prefix all names
   }
@@ -305,7 +305,7 @@ private:
 
   static void printFloat(std::ostream &o, float f) {
     if (std::isnan(f)) {
-      const char *sign = std::signbit(f) ? "-" : "";
+      const char* sign = std::signbit(f) ? "-" : "";
       o << sign << "nan";
       if (uint32_t payload = NaNPayload(f)) {
         o << ":0x" << std::hex << payload << std::dec;
@@ -315,13 +315,13 @@ private:
     printDouble(o, f);
   }
 
-  static void printDouble(std::ostream &o, double d) {
+  static void printDouble(std::ostream& o, double d) {
     if (d == 0 && std::signbit(d)) {
       o << "-0";
       return;
     }
     if (std::isnan(d)) {
-      const char *sign = std::signbit(d) ? "-" : "";
+      const char* sign = std::signbit(d) ? "-" : "";
       o << sign << "nan";
       if (uint64_t payload = NaNPayload(d)) {
         o << ":0x" << std::hex << payload << std::dec;
@@ -332,7 +332,7 @@ private:
       o << (std::signbit(d) ? "-infinity" : "infinity");
       return;
     }
-    const char *text = cashew::JSPrinter::numToString(d);
+    const char* text = cashew::JSPrinter::numToString(d);
     // spec interpreter hates floats starting with '.'
     if (text[0] == '.') {
       o << '0';
@@ -343,7 +343,7 @@ private:
     o << text;
   }
 
-  friend std::ostream& operator<<(std::ostream &o, Literal literal) {
+  friend std::ostream& operator<<(std::ostream& o, Literal literal) {
     o << '(';
     prepareMinorColor(o) << printWasmType(literal.type) << ".const ";
     switch (literal.type) {
@@ -909,7 +909,7 @@ public:
   }
 };
 
-inline const char *getExpressionName(Expression *curr) {
+inline const char* getExpressionName(Expression* curr) {
   switch (curr->_id) {
     case Expression::Id::InvalidId: abort();
     case Expression::Id::BlockId: return "block";
@@ -978,7 +978,9 @@ public:
   If() : ifFalse(nullptr) {}
   If(MixedArena& allocator) : If() {}
 
-  Expression *condition, *ifTrue, *ifFalse;
+  Expression* condition;
+  Expression* ifTrue;
+  Expression* ifFalse;
 
   // set the type given you know its type, which is the case when parsing
   // s-expression or binary, as explicit types are given. the only additional work
@@ -995,7 +997,7 @@ public:
   Loop(MixedArena& allocator) {}
 
   Name name;
-  Expression *body;
+  Expression* body;
 
   // set the type given you know its type, which is the case when parsing
   // s-expression or binary, as explicit types are given. the only additional work
@@ -1014,8 +1016,8 @@ public:
   }
 
   Name name;
-  Expression *value;
-  Expression *condition;
+  Expression* value;
+  Expression* condition;
 
   void finalize() {
     if (condition) {
@@ -1038,8 +1040,8 @@ public:
 
   ArenaVector<Name> targets;
   Name default_;
-  Expression *condition;
-  Expression *value;
+  Expression* condition;
+  Expression* value;
 };
 
 class Call : public SpecificExpression<Expression::CallId> {
@@ -1090,7 +1092,7 @@ public:
 
   ExpressionList operands;
   Name fullType;
-  Expression *target;
+  Expression* target;
 };
 
 class GetLocal : public SpecificExpression<Expression::GetLocalId> {
@@ -1107,7 +1109,7 @@ public:
   SetLocal(MixedArena& allocator) {}
 
   Index index;
-  Expression *value;
+  Expression* value;
 
   bool isTee() {
     return type != none;
@@ -1133,7 +1135,7 @@ public:
   SetGlobal(MixedArena& allocator) {}
 
   Name name;
-  Expression *value;
+  Expression* value;
 };
 
 class Load : public SpecificExpression<Expression::LoadId> {
@@ -1145,7 +1147,7 @@ public:
   bool signed_;
   Address offset;
   Address align;
-  Expression *ptr;
+  Expression* ptr;
 
   // type must be set during creation, cannot be inferred
 };
@@ -1158,7 +1160,8 @@ public:
   uint8_t bytes;
   Address offset;
   Address align;
-  Expression *ptr, *value;
+  Expression* ptr;
+  Expression* value;
   WasmType valueType; // the store never returns a value
 
   void finalize() {
@@ -1186,7 +1189,7 @@ public:
   Unary(MixedArena& allocator) {}
 
   UnaryOp op;
-  Expression *value;
+  Expression* value;
 
   bool isRelational() { return op == EqZInt32 || op == EqZInt64; }
 
@@ -1249,7 +1252,8 @@ public:
   Binary(MixedArena& allocator) {}
 
   BinaryOp op;
-  Expression *left, *right;
+  Expression* left;
+  Expression* right;
 
   // the type is always the type of the operands,
   // except for relationals
@@ -1307,7 +1311,9 @@ public:
   Select() {}
   Select(MixedArena& allocator) {}
 
-  Expression *ifTrue, *ifFalse, *condition;
+  Expression* ifTrue;
+  Expression* ifFalse;
+  Expression* condition;
 
   void finalize() {
     assert(ifTrue && ifFalse);
@@ -1320,7 +1326,7 @@ public:
   Drop() {}
   Drop(MixedArena& allocator) {}
 
-  Expression *value;
+  Expression* value;
 };
 
 class Return : public SpecificExpression<Expression::ReturnId> {
@@ -1330,7 +1336,7 @@ public:
   }
   Return(MixedArena& allocator) : Return() {}
 
-  Expression *value;
+  Expression* value;
 };
 
 class Host : public SpecificExpression<Expression::HostId> {
@@ -1373,7 +1379,7 @@ public:
   std::vector<WasmType> params; // function locals are
   std::vector<WasmType> vars;   // params plus vars
   Name type; // if null, it is implicit in params and result
-  Expression *body;
+  Expression* body;
 
   // local names. these are optional.
   std::vector<Name> localNames;
@@ -1489,7 +1495,7 @@ public:
     Expression* offset;
     std::vector<char> data; // TODO: optimize
     Segment() {}
-    Segment(Expression* offset, const char *init, Address size) : offset(offset) {
+    Segment(Expression* offset, const char* init, Address size) : offset(offset) {
       data.resize(size);
       std::copy_n(init, size, data.begin());
     }
@@ -1588,7 +1594,7 @@ public:
     globalsMap[curr->name] = curr;
   }
 
-  void addStart(const Name &s) {
+  void addStart(const Name& s) {
     start = s;
   }