use * for pointer type instead of &

See #770

To help automatically translate code, see the
zig-fmt-pointer-reform-2 branch.

This will convert all & into *. Due to the syntax
ambiguity (which is why we are making this change),
even address-of & will turn into *, so you'll have
to manually fix thes instances. You will be guaranteed
to get compile errors for them - expected 'type', found 'foo'

std/buffer.zig

@@ -12,14 +12,14 @@ pub const Buffer = struct {
     list: ArrayList(u8),
 
     /// Must deinitialize with deinit.
-    pub fn init(allocator: &Allocator, m: []const u8) !Buffer {
+    pub fn init(allocator: *Allocator, m: []const u8) !Buffer {
         var self = try initSize(allocator, m.len);
         mem.copy(u8, self.list.items, m);
         return self;
     }
 
     /// Must deinitialize with deinit.
-    pub fn initSize(allocator: &Allocator, size: usize) !Buffer {
+    pub fn initSize(allocator: *Allocator, size: usize) !Buffer {
         var self = initNull(allocator);
         try self.resize(size);
         return self;
@@ -30,19 +30,19 @@ pub const Buffer = struct {
     /// * ::replaceContents
     /// * ::replaceContentsBuffer
     /// * ::resize
-    pub fn initNull(allocator: &Allocator) Buffer {
+    pub fn initNull(allocator: *Allocator) Buffer {
         return Buffer{ .list = ArrayList(u8).init(allocator) };
     }
 
     /// Must deinitialize with deinit.
-    pub fn initFromBuffer(buffer: &const Buffer) !Buffer {
+    pub fn initFromBuffer(buffer: *const Buffer) !Buffer {
         return Buffer.init(buffer.list.allocator, buffer.toSliceConst());
     }
 
     /// Buffer takes ownership of the passed in slice. The slice must have been
     /// allocated with `allocator`.
     /// Must deinitialize with deinit.
-    pub fn fromOwnedSlice(allocator: &Allocator, slice: []u8) Buffer {
+    pub fn fromOwnedSlice(allocator: *Allocator, slice: []u8) Buffer {
         var self = Buffer{ .list = ArrayList(u8).fromOwnedSlice(allocator, slice) };
         self.list.append(0);
         return self;
@@ -50,79 +50,79 @@ pub const Buffer = struct {
 
     /// The caller owns the returned memory. The Buffer becomes null and
     /// is safe to `deinit`.
-    pub fn toOwnedSlice(self: &Buffer) []u8 {
+    pub fn toOwnedSlice(self: *Buffer) []u8 {
         const allocator = self.list.allocator;
         const result = allocator.shrink(u8, self.list.items, self.len());
         self.* = initNull(allocator);
         return result;
     }
 
-    pub fn deinit(self: &Buffer) void {
+    pub fn deinit(self: *Buffer) void {
         self.list.deinit();
     }
 
-    pub fn toSlice(self: &const Buffer) []u8 {
+    pub fn toSlice(self: *const Buffer) []u8 {
         return self.list.toSlice()[0..self.len()];
     }
 
-    pub fn toSliceConst(self: &const Buffer) []const u8 {
+    pub fn toSliceConst(self: *const Buffer) []const u8 {
         return self.list.toSliceConst()[0..self.len()];
     }
 
-    pub fn shrink(self: &Buffer, new_len: usize) void {
+    pub fn shrink(self: *Buffer, new_len: usize) void {
         assert(new_len <= self.len());
         self.list.shrink(new_len + 1);
         self.list.items[self.len()] = 0;
     }
 
-    pub fn resize(self: &Buffer, new_len: usize) !void {
+    pub fn resize(self: *Buffer, new_len: usize) !void {
         try self.list.resize(new_len + 1);
         self.list.items[self.len()] = 0;
     }
 
-    pub fn isNull(self: &const Buffer) bool {
+    pub fn isNull(self: *const Buffer) bool {
         return self.list.len == 0;
     }
 
-    pub fn len(self: &const Buffer) usize {
+    pub fn len(self: *const Buffer) usize {
         return self.list.len - 1;
     }
 
-    pub fn append(self: &Buffer, m: []const u8) !void {
+    pub fn append(self: *Buffer, m: []const u8) !void {
         const old_len = self.len();
         try self.resize(old_len + m.len);
         mem.copy(u8, self.list.toSlice()[old_len..], m);
     }
 
-    pub fn appendByte(self: &Buffer, byte: u8) !void {
+    pub fn appendByte(self: *Buffer, byte: u8) !void {
         const old_len = self.len();
         try self.resize(old_len + 1);
         self.list.toSlice()[old_len] = byte;
     }
 
-    pub fn eql(self: &const Buffer, m: []const u8) bool {
+    pub fn eql(self: *const Buffer, m: []const u8) bool {
         return mem.eql(u8, self.toSliceConst(), m);
     }
 
-    pub fn startsWith(self: &const Buffer, m: []const u8) bool {
+    pub fn startsWith(self: *const Buffer, m: []const u8) bool {
         if (self.len() < m.len) return false;
         return mem.eql(u8, self.list.items[0..m.len], m);
     }
 
-    pub fn endsWith(self: &const Buffer, m: []const u8) bool {
+    pub fn endsWith(self: *const Buffer, m: []const u8) bool {
         const l = self.len();
         if (l < m.len) return false;
         const start = l - m.len;
         return mem.eql(u8, self.list.items[start..l], m);
     }
 
-    pub fn replaceContents(self: &const Buffer, m: []const u8) !void {
+    pub fn replaceContents(self: *const Buffer, m: []const u8) !void {
         try self.resize(m.len);
         mem.copy(u8, self.list.toSlice(), m);
     }
 
     /// For passing to C functions.
-    pub fn ptr(self: &const Buffer) &u8 {
+    pub fn ptr(self: *const Buffer) *u8 {
         return self.list.items.ptr;
     }
 };