fixups

ggreif · ggreif · commit b1fa644a1dcf · 2020-10-09T23:41:49.000+02:00
diff --git a/lldb/source/Plugins/ExpressionParser/Rust/RustAST.h b/lldb/source/Plugins/ExpressionParser/Rust/RustAST.h
@@ -613,7 +613,7 @@ class RustPathExpression : public RustExpression {
     std::vector<std::string> names;
     names.push_back(std::move(item));
 
-    m_path = llvm::make_unique<RustPath>(false, true, 0, std::move(names),
+    m_path = std::make_unique<RustPath>(false, true, 0, std::move(names),
                                          std::vector<RustTypeExpressionUP>());
   }
 
@@ -694,7 +694,7 @@ class RustPathTypeExpression : public RustTypeExpression {
     std::vector<std::string> names;
     names.push_back(std::move(item));
 
-    m_path = llvm::make_unique<RustPath>(false, true, 0, std::move(names),
+    m_path = std::make_unique<RustPath>(false, true, 0, std::move(names),
                                          std::vector<RustTypeExpressionUP>());
   }
 
diff --git a/lldb/source/Plugins/ExpressionParser/Rust/RustLex.cpp b/lldb/source/Plugins/ExpressionParser/Rust/RustLex.cpp
@@ -40,7 +40,7 @@ void lldb_private::rust::PrintTokenKind(Stream &stream, int kind) {
     case INVALID:
     case THATSALLFOLKS:
       // May want to clean this up someday.
-      stream << "[TOKEN=" << kind << "]";
+      //stream << "[TOKEN=" << kind << "]";
       break;
 
     case DOTDOT:
diff --git a/lldb/source/Plugins/ExpressionParser/Rust/RustLex.h b/lldb/source/Plugins/ExpressionParser/Rust/RustLex.h
@@ -16,6 +16,7 @@
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "lldb/Utility/Stream.h"
 
diff --git a/lldb/source/Plugins/ExpressionParser/Rust/RustParse.cpp b/lldb/source/Plugins/ExpressionParser/Rust/RustParse.cpp
@@ -1328,7 +1328,7 @@ RustExpressionUP Parser::Unary(Status &error) {
   if (!result) {
     return result;
   }
-  return llvm::make_unique<RustUnaryExpression<C, OP>>(std::move(result));
+  return std::make_unique<RustUnaryExpression<C, OP>>(std::move(result));
 }
 
 bool Parser::ExprList(std::vector<RustExpressionUP> *exprs, Status &error) {
@@ -1357,7 +1357,7 @@ RustExpressionUP Parser::Parens(Status &error) {
   if (CurrentToken().kind == ')') {
     // Unit tuple.
     Advance();
-    return llvm::make_unique<RustTupleExpression>(std::vector<RustExpressionUP>());
+    return std::make_unique<RustTupleExpression>(std::vector<RustExpressionUP>());
   }
 
   RustExpressionUP expr = Expr(error);
@@ -1390,7 +1390,7 @@ RustExpressionUP Parser::Parens(Status &error) {
   }
   Advance();
 
-  return llvm::make_unique<RustTupleExpression>(std::move(exprs));
+  return std::make_unique<RustTupleExpression>(std::move(exprs));
 }
 
 RustExpressionUP Parser::Array(Status &error) {
@@ -1416,14 +1416,14 @@ RustExpressionUP Parser::Array(Status &error) {
       return length;
     }
 
-    result = llvm::make_unique<RustArrayWithLength>(std::move(expr), std::move(length));
+    result = std::make_unique<RustArrayWithLength>(std::move(expr), std::move(length));
   } else if (CurrentToken().kind == ',') {
     Advance();
     std::vector<RustExpressionUP> exprs;
     exprs.push_back(std::move(expr));
 
     if (ExprList(&exprs, error)) {
-      result = llvm::make_unique<RustArrayLiteral>(std::move(exprs));
+      result = std::make_unique<RustArrayLiteral>(std::move(exprs));
     }
   } else {
     error.SetErrorString("expected ',' or ';'");
@@ -1446,11 +1446,11 @@ RustExpressionUP Parser::Field(RustExpressionUP &&lhs, Status &error) {
 
   RustExpressionUP result;
   if (CurrentToken().kind == IDENTIFIER) {
-    result = llvm::make_unique<RustFieldExpression>(std::move(lhs),
+    result = std::make_unique<RustFieldExpression>(std::move(lhs),
                                                     CurrentToken().str);
     Advance();
   } else if (CurrentToken().kind == INTEGER) {
-    result = llvm::make_unique<RustTupleFieldExpression>(std::move(lhs),
+    result = std::make_unique<RustTupleFieldExpression>(std::move(lhs),
                                                          CurrentToken().uinteger.getValue());
     Advance();
   } else {
@@ -1477,7 +1477,7 @@ RustExpressionUP Parser::Call(RustExpressionUP &&func, Status &error) {
   }
   Advance();
 
-  return llvm::make_unique<RustCall>(std::move(func), std::move(exprs));
+  return std::make_unique<RustCall>(std::move(func), std::move(exprs));
 }
 
 RustExpressionUP Parser::Index(RustExpressionUP &&array, Status &error) {
@@ -1495,7 +1495,7 @@ RustExpressionUP Parser::Index(RustExpressionUP &&array, Status &error) {
   }
   Advance();
 
-  return llvm::make_unique<RustBinaryExpression<'@', ArrayIndex>>(std::move(array),
+  return std::make_unique<RustBinaryExpression<'@', ArrayIndex>>(std::move(array),
                                                                   std::move(idx));
 }
 
@@ -1514,7 +1514,7 @@ RustExpressionUP Parser::Struct(RustTypeExpressionUP &&path, Status &error) {
       if (CurrentToken().kind == ',' || CurrentToken().kind == '}') {
         // Plain "field".
         std::string field_copy = field;
-        value = llvm::make_unique<RustPathExpression>(std::move(field_copy));
+        value = std::make_unique<RustPathExpression>(std::move(field_copy));
       } else if (CurrentToken().kind != ':') {
         error.SetErrorString("':' expected");
         return RustExpressionUP();
@@ -1556,7 +1556,7 @@ RustExpressionUP Parser::Struct(RustTypeExpressionUP &&path, Status &error) {
   }
   Advance();
 
-  return llvm::make_unique<RustStructExpression>(std::move(path), std::move(inits),
+  return std::make_unique<RustStructExpression>(std::move(path), std::move(inits),
                                                  std::move(copy));
 }
 
@@ -1570,7 +1570,7 @@ RustExpressionUP Parser::Path(Status &error) {
     if (CurrentToken().kind != COLONCOLON) {
       // This one can't be a struct expression, so we just return
       // directly.
-      return llvm::make_unique<RustPathExpression>(std::string("self"));
+      return std::make_unique<RustPathExpression>(std::string("self"));
     }
   }
 
@@ -1620,17 +1620,17 @@ RustExpressionUP Parser::Path(Status &error) {
   }
 
   if (CurrentToken().kind == '{') {
-    RustPathUP name_path = llvm::make_unique<RustPath>(saw_self, relative, supers,
+    RustPathUP name_path = std::make_unique<RustPath>(saw_self, relative, supers,
                                                        std::move(path), std::move(type_list),
                                                        true);
     RustTypeExpressionUP type_path =
-      llvm::make_unique<RustPathTypeExpression>(std::move(name_path));
+      std::make_unique<RustPathTypeExpression>(std::move(name_path));
     return Struct(std::move(type_path), error);
   }
 
-  RustPathUP name_path = llvm::make_unique<RustPath>(saw_self, relative, supers,
+  RustPathUP name_path = std::make_unique<RustPath>(saw_self, relative, supers,
                                                      std::move(path), std::move(type_list));
-  return llvm::make_unique<RustPathExpression>(std::move(name_path));
+  return std::make_unique<RustPathExpression>(std::move(name_path));
 }
 
 RustExpressionUP Parser::Sizeof(Status &error) {
@@ -1654,7 +1654,7 @@ RustExpressionUP Parser::Sizeof(Status &error) {
   }
   Advance();
 
-  return llvm::make_unique<RustUnaryExpression<'@', UnarySizeof>>(std::move(expr));
+  return std::make_unique<RustUnaryExpression<'@', UnarySizeof>>(std::move(expr));
 }
 
 bool Parser::StartsTerm() {
@@ -1699,8 +1699,8 @@ RustExpressionUP Parser::Term(Status &error) {
     if (!suffix) {
       suffix = "i32";
     }
-    RustTypeExpressionUP type = llvm::make_unique<RustPathTypeExpression>(suffix);
-    term = llvm::make_unique<RustLiteral>(CurrentToken().uinteger.getValue(), std::move(type));
+    RustTypeExpressionUP type = std::make_unique<RustPathTypeExpression>(suffix);
+    term = std::make_unique<RustLiteral>(CurrentToken().uinteger.getValue(), std::move(type));
     Advance();
     break;
   }
@@ -1710,29 +1710,29 @@ RustExpressionUP Parser::Term(Status &error) {
     if (!suffix) {
       suffix = "f64";
     }
-    RustTypeExpressionUP type = llvm::make_unique<RustPathTypeExpression>(suffix);
-    term = llvm::make_unique<RustLiteral>(CurrentToken().dvalue.getValue(), std::move(type));
+    RustTypeExpressionUP type = std::make_unique<RustPathTypeExpression>(suffix);
+    term = std::make_unique<RustLiteral>(CurrentToken().dvalue.getValue(), std::move(type));
     Advance();
     break;
   }
 
   case STRING:
   case BYTESTRING:
-    term = llvm::make_unique<RustStringLiteral>(std::move(CurrentToken().str),
+    term = std::make_unique<RustStringLiteral>(std::move(CurrentToken().str),
                                                 CurrentToken().kind == BYTESTRING);
     Advance();
     break;
 
   case CHAR:
   case BYTE:
-    term = llvm::make_unique<RustCharLiteral>(CurrentToken().uinteger.getValue(),
+    term = std::make_unique<RustCharLiteral>(CurrentToken().uinteger.getValue(),
                                               CurrentToken().kind == BYTE);
     Advance();
     break;
 
   case TRUE:
   case FALSE:
-    term = llvm::make_unique<RustBooleanLiteral>(CurrentToken().kind == TRUE);
+    term = std::make_unique<RustBooleanLiteral>(CurrentToken().kind == TRUE);
     Advance();
     break;
 
@@ -1800,7 +1800,7 @@ RustExpressionUP Parser::Term(Status &error) {
       if (!type) {
         return RustExpressionUP();
       }
-      term = llvm::make_unique<RustCast>(std::move(type), std::move(term));
+      term = std::make_unique<RustCast>(std::move(type), std::move(term));
       break;
     }
 
@@ -1952,7 +1952,7 @@ RustExpressionUP Parser::Binary(Status &error) {
       switch (top.op) {
 #define DEFINE(Token, Prec, Type)                                       \
         case Token:                                                     \
-          lhs.term = llvm::make_unique<Type>(std::move(lhs.term), std::move(top.term)); \
+          lhs.term = std::make_unique<Type>(std::move(lhs.term), std::move(top.term)); \
           break;
 
         BINARY_OPERATORS
@@ -1998,7 +1998,7 @@ RustExpressionUP Parser::Range(Status &error) {
     }
   }
 
-  return llvm::make_unique<RustRangeExpression>(std::move(lhs), std::move(rhs), is_inclusive);
+  return std::make_unique<RustRangeExpression>(std::move(lhs), std::move(rhs), is_inclusive);
 }
 
 ////////////////////////////////////////////////////////////////
@@ -2033,7 +2033,7 @@ RustTypeExpressionUP Parser::ArrayType(Status &error) {
   }
   Advance();
 
-  return llvm::make_unique<RustArrayTypeExpression>(std::move(element), len);
+  return std::make_unique<RustArrayTypeExpression>(std::move(element), len);
 }
 
 RustTypeExpressionUP Parser::ReferenceType(Status &error) {
@@ -2064,10 +2064,10 @@ RustTypeExpressionUP Parser::ReferenceType(Status &error) {
     }
     Advance();
 
-    return llvm::make_unique<RustSliceTypeExpression>(std::move(target), is_mut);
+    return std::make_unique<RustSliceTypeExpression>(std::move(target), is_mut);
   }
 
-  return llvm::make_unique<RustPointerTypeExpression>(std::move(target), true, is_mut);
+  return std::make_unique<RustPointerTypeExpression>(std::move(target), true, is_mut);
 }
 
 RustTypeExpressionUP Parser::PointerType(Status &error) {
@@ -2088,7 +2088,7 @@ RustTypeExpressionUP Parser::PointerType(Status &error) {
     return target;
   }
 
-  return llvm::make_unique<RustPointerTypeExpression>(std::move(target), false, is_mut);
+  return std::make_unique<RustPointerTypeExpression>(std::move(target), false, is_mut);
 }
 
 bool Parser::TypeList(std::vector<RustTypeExpressionUP> *type_list, Status &error) {
@@ -2174,7 +2174,7 @@ RustTypeExpressionUP Parser::FunctionType(Status &error) {
     return return_type;
   }
 
-  return llvm::make_unique<RustFunctionTypeExpression>(std::move(return_type),
+  return std::make_unique<RustFunctionTypeExpression>(std::move(return_type),
                                                        std::move(type_list));
 }
 
@@ -2188,7 +2188,7 @@ RustTypeExpressionUP Parser::TupleType(Status &error) {
     return RustTypeExpressionUP();
   }
 
-  return llvm::make_unique<RustTupleTypeExpression>(std::move(type_list));
+  return std::make_unique<RustTupleTypeExpression>(std::move(type_list));
 }
 
 RustTypeExpressionUP Parser::TypePath(Status &error) {
@@ -2249,9 +2249,9 @@ RustTypeExpressionUP Parser::TypePath(Status &error) {
     return RustTypeExpressionUP();
   }
 
-  RustPathUP name_path = llvm::make_unique<RustPath>(saw_self, relative, supers, std::move(path),
+  RustPathUP name_path = std::make_unique<RustPath>(saw_self, relative, supers, std::move(path),
                                                      std::move(type_list));
-  return llvm::make_unique<RustPathTypeExpression>(std::move(name_path));
+  return std::make_unique<RustPathTypeExpression>(std::move(name_path));
 }
 
 RustTypeExpressionUP Parser::Type(Status &error) {

Original file line number	Diff line number	Diff line change
`@@ -613,7 +613,7 @@ class RustPathExpression : public RustExpression {`
`613`	`613`	`std::vector<std::string> names;`
`614`	`614`	`names.push_back(std::move(item));`
`615`	`615`
`616`		`- m_path = llvm::make_unique<RustPath>(false, true, 0, std::move(names),`
	`616`	`+ m_path = std::make_unique<RustPath>(false, true, 0, std::move(names),`
`617`	`617`	`std::vector<RustTypeExpressionUP>());`
`618`	`618`	`}`
`619`	`619`
`@@ -694,7 +694,7 @@ class RustPathTypeExpression : public RustTypeExpression {`
`694`	`694`	`std::vector<std::string> names;`
`695`	`695`	`names.push_back(std::move(item));`
`696`	`696`
`697`		`- m_path = llvm::make_unique<RustPath>(false, true, 0, std::move(names),`
	`697`	`+ m_path = std::make_unique<RustPath>(false, true, 0, std::move(names),`
`698`	`698`	`std::vector<RustTypeExpressionUP>());`
`699`	`699`	`}`
`700`	`700`
Original file line number	Diff line number	Diff line change
`@@ -1328,7 +1328,7 @@ RustExpressionUP Parser::Unary(Status &error) {`
`1328`	`1328`	`if (!result) {`
`1329`	`1329`	`return result;`
`1330`	`1330`	`}`
`1331`		`- return llvm::make_unique<RustUnaryExpression<C, OP>>(std::move(result));`
	`1331`	`+ return std::make_unique<RustUnaryExpression<C, OP>>(std::move(result));`
`1332`	`1332`	`}`
`1333`	`1333`
`1334`	`1334`	`bool Parser::ExprList(std::vector<RustExpressionUP> *exprs, Status &error) {`
`@@ -1357,7 +1357,7 @@ RustExpressionUP Parser::Parens(Status &error) {`
`1357`	`1357`	`if (CurrentToken().kind == ')') {`
`1358`	`1358`	`// Unit tuple.`
`1359`	`1359`	`Advance();`
`1360`		`- return llvm::make_unique<RustTupleExpression>(std::vector<RustExpressionUP>());`
	`1360`	`+ return std::make_unique<RustTupleExpression>(std::vector<RustExpressionUP>());`
`1361`	`1361`	`}`
`1362`	`1362`
`1363`	`1363`	`RustExpressionUP expr = Expr(error);`
`@@ -1390,7 +1390,7 @@ RustExpressionUP Parser::Parens(Status &error) {`
`1390`	`1390`	`}`
`1391`	`1391`	`Advance();`
`1392`	`1392`
`1393`		`- return llvm::make_unique<RustTupleExpression>(std::move(exprs));`
	`1393`	`+ return std::make_unique<RustTupleExpression>(std::move(exprs));`
`1394`	`1394`	`}`
`1395`	`1395`
`1396`	`1396`	`RustExpressionUP Parser::Array(Status &error) {`
`@@ -1416,14 +1416,14 @@ RustExpressionUP Parser::Array(Status &error) {`
`1416`	`1416`	`return length;`
`1417`	`1417`	`}`
`1418`	`1418`
`1419`		`- result = llvm::make_unique<RustArrayWithLength>(std::move(expr), std::move(length));`
	`1419`	`+ result = std::make_unique<RustArrayWithLength>(std::move(expr), std::move(length));`
`1420`	`1420`	`} else if (CurrentToken().kind == ',') {`
`1421`	`1421`	`Advance();`
`1422`	`1422`	`std::vector<RustExpressionUP> exprs;`
`1423`	`1423`	`exprs.push_back(std::move(expr));`
`1424`	`1424`
`1425`	`1425`	`if (ExprList(&exprs, error)) {`
`1426`		`- result = llvm::make_unique<RustArrayLiteral>(std::move(exprs));`
	`1426`	`+ result = std::make_unique<RustArrayLiteral>(std::move(exprs));`
`1427`	`1427`	`}`
`1428`	`1428`	`} else {`
`1429`	`1429`	`error.SetErrorString("expected ',' or ';'");`
`@@ -1446,11 +1446,11 @@ RustExpressionUP Parser::Field(RustExpressionUP &&lhs, Status &error) {`
`1446`	`1446`
`1447`	`1447`	`RustExpressionUP result;`
`1448`	`1448`	`if (CurrentToken().kind == IDENTIFIER) {`
`1449`		`- result = llvm::make_unique<RustFieldExpression>(std::move(lhs),`
	`1449`	`+ result = std::make_unique<RustFieldExpression>(std::move(lhs),`
`1450`	`1450`	`CurrentToken().str);`
`1451`	`1451`	`Advance();`
`1452`	`1452`	`} else if (CurrentToken().kind == INTEGER) {`
`1453`		`- result = llvm::make_unique<RustTupleFieldExpression>(std::move(lhs),`
	`1453`	`+ result = std::make_unique<RustTupleFieldExpression>(std::move(lhs),`
`1454`	`1454`	`CurrentToken().uinteger.getValue());`
`1455`	`1455`	`Advance();`
`1456`	`1456`	`} else {`
`@@ -1477,7 +1477,7 @@ RustExpressionUP Parser::Call(RustExpressionUP &&func, Status &error) {`
`1477`	`1477`	`}`
`1478`	`1478`	`Advance();`
`1479`	`1479`
`1480`		`- return llvm::make_unique<RustCall>(std::move(func), std::move(exprs));`
	`1480`	`+ return std::make_unique<RustCall>(std::move(func), std::move(exprs));`
`1481`	`1481`	`}`
`1482`	`1482`
`1483`	`1483`	`RustExpressionUP Parser::Index(RustExpressionUP &&array, Status &error) {`
`@@ -1495,7 +1495,7 @@ RustExpressionUP Parser::Index(RustExpressionUP &&array, Status &error) {`
`1495`	`1495`	`}`
`1496`	`1496`	`Advance();`
`1497`	`1497`
`1498`		`- return llvm::make_unique<RustBinaryExpression<'@', ArrayIndex>>(std::move(array),`
	`1498`	`+ return std::make_unique<RustBinaryExpression<'@', ArrayIndex>>(std::move(array),`
`1499`	`1499`	`std::move(idx));`
`1500`	`1500`	`}`
`1501`	`1501`
`@@ -1514,7 +1514,7 @@ RustExpressionUP Parser::Struct(RustTypeExpressionUP &&path, Status &error) {`
`1514`	`1514`	`if (CurrentToken().kind == ',' \|\| CurrentToken().kind == '}') {`
`1515`	`1515`	`// Plain "field".`
`1516`	`1516`	`std::string field_copy = field;`
`1517`		`- value = llvm::make_unique<RustPathExpression>(std::move(field_copy));`
	`1517`	`+ value = std::make_unique<RustPathExpression>(std::move(field_copy));`
`1518`	`1518`	`} else if (CurrentToken().kind != ':') {`
`1519`	`1519`	`error.SetErrorString("':' expected");`
`1520`	`1520`	`return RustExpressionUP();`
`@@ -1556,7 +1556,7 @@ RustExpressionUP Parser::Struct(RustTypeExpressionUP &&path, Status &error) {`
`1556`	`1556`	`}`
`1557`	`1557`	`Advance();`
`1558`	`1558`
`1559`		`- return llvm::make_unique<RustStructExpression>(std::move(path), std::move(inits),`
	`1559`	`+ return std::make_unique<RustStructExpression>(std::move(path), std::move(inits),`
`1560`	`1560`	`std::move(copy));`
`1561`	`1561`	`}`
`1562`	`1562`
`@@ -1570,7 +1570,7 @@ RustExpressionUP Parser::Path(Status &error) {`
`1570`	`1570`	`if (CurrentToken().kind != COLONCOLON) {`
`1571`	`1571`	`// This one can't be a struct expression, so we just return`
`1572`	`1572`	`// directly.`
`1573`		`- return llvm::make_unique<RustPathExpression>(std::string("self"));`
	`1573`	`+ return std::make_unique<RustPathExpression>(std::string("self"));`
`1574`	`1574`	`}`
`1575`	`1575`	`}`
`1576`	`1576`
`@@ -1620,17 +1620,17 @@ RustExpressionUP Parser::Path(Status &error) {`
`1620`	`1620`	`}`
`1621`	`1621`
`1622`	`1622`	`if (CurrentToken().kind == '{') {`
`1623`		`- RustPathUP name_path = llvm::make_unique<RustPath>(saw_self, relative, supers,`
	`1623`	`+ RustPathUP name_path = std::make_unique<RustPath>(saw_self, relative, supers,`
`1624`	`1624`	`std::move(path), std::move(type_list),`
`1625`	`1625`	`true);`
`1626`	`1626`	`RustTypeExpressionUP type_path =`
`1627`		`- llvm::make_unique<RustPathTypeExpression>(std::move(name_path));`
	`1627`	`+ std::make_unique<RustPathTypeExpression>(std::move(name_path));`
`1628`	`1628`	`return Struct(std::move(type_path), error);`
`1629`	`1629`	`}`
`1630`	`1630`
`1631`		`- RustPathUP name_path = llvm::make_unique<RustPath>(saw_self, relative, supers,`
	`1631`	`+ RustPathUP name_path = std::make_unique<RustPath>(saw_self, relative, supers,`
`1632`	`1632`	`std::move(path), std::move(type_list));`
`1633`		`- return llvm::make_unique<RustPathExpression>(std::move(name_path));`
	`1633`	`+ return std::make_unique<RustPathExpression>(std::move(name_path));`
`1634`	`1634`	`}`
`1635`	`1635`
`1636`	`1636`	`RustExpressionUP Parser::Sizeof(Status &error) {`
`@@ -1654,7 +1654,7 @@ RustExpressionUP Parser::Sizeof(Status &error) {`
`1654`	`1654`	`}`
`1655`	`1655`	`Advance();`
`1656`	`1656`
`1657`		`- return llvm::make_unique<RustUnaryExpression<'@', UnarySizeof>>(std::move(expr));`
	`1657`	`+ return std::make_unique<RustUnaryExpression<'@', UnarySizeof>>(std::move(expr));`
`1658`	`1658`	`}`
`1659`	`1659`
`1660`	`1660`	`bool Parser::StartsTerm() {`
`@@ -1699,8 +1699,8 @@ RustExpressionUP Parser::Term(Status &error) {`
`1699`	`1699`	`if (!suffix) {`
`1700`	`1700`	`suffix = "i32";`
`1701`	`1701`	`}`
`1702`		`- RustTypeExpressionUP type = llvm::make_unique<RustPathTypeExpression>(suffix);`
`1703`		`- term = llvm::make_unique<RustLiteral>(CurrentToken().uinteger.getValue(), std::move(type));`
	`1702`	`+ RustTypeExpressionUP type = std::make_unique<RustPathTypeExpression>(suffix);`
	`1703`	`+ term = std::make_unique<RustLiteral>(CurrentToken().uinteger.getValue(), std::move(type));`
`1704`	`1704`	`Advance();`
`1705`	`1705`	`break;`
`1706`	`1706`	`}`
`@@ -1710,29 +1710,29 @@ RustExpressionUP Parser::Term(Status &error) {`
`1710`	`1710`	`if (!suffix) {`
`1711`	`1711`	`suffix = "f64";`
`1712`	`1712`	`}`
`1713`		`- RustTypeExpressionUP type = llvm::make_unique<RustPathTypeExpression>(suffix);`
`1714`		`- term = llvm::make_unique<RustLiteral>(CurrentToken().dvalue.getValue(), std::move(type));`
	`1713`	`+ RustTypeExpressionUP type = std::make_unique<RustPathTypeExpression>(suffix);`
	`1714`	`+ term = std::make_unique<RustLiteral>(CurrentToken().dvalue.getValue(), std::move(type));`
`1715`	`1715`	`Advance();`
`1716`	`1716`	`break;`
`1717`	`1717`	`}`
`1718`	`1718`
`1719`	`1719`	`case STRING:`
`1720`	`1720`	`case BYTESTRING:`
`1721`		`- term = llvm::make_unique<RustStringLiteral>(std::move(CurrentToken().str),`
	`1721`	`+ term = std::make_unique<RustStringLiteral>(std::move(CurrentToken().str),`
`1722`	`1722`	`CurrentToken().kind == BYTESTRING);`
`1723`	`1723`	`Advance();`
`1724`	`1724`	`break;`
`1725`	`1725`
`1726`	`1726`	`case CHAR:`
`1727`	`1727`	`case BYTE:`
`1728`		`- term = llvm::make_unique<RustCharLiteral>(CurrentToken().uinteger.getValue(),`
	`1728`	`+ term = std::make_unique<RustCharLiteral>(CurrentToken().uinteger.getValue(),`
`1729`	`1729`	`CurrentToken().kind == BYTE);`
`1730`	`1730`	`Advance();`
`1731`	`1731`	`break;`
`1732`	`1732`
`1733`	`1733`	`case TRUE:`
`1734`	`1734`	`case FALSE:`
`1735`		`- term = llvm::make_unique<RustBooleanLiteral>(CurrentToken().kind == TRUE);`
	`1735`	`+ term = std::make_unique<RustBooleanLiteral>(CurrentToken().kind == TRUE);`
`1736`	`1736`	`Advance();`
`1737`	`1737`	`break;`
`1738`	`1738`
`@@ -1800,7 +1800,7 @@ RustExpressionUP Parser::Term(Status &error) {`
`1800`	`1800`	`if (!type) {`
`1801`	`1801`	`return RustExpressionUP();`
`1802`	`1802`	`}`
`1803`		`- term = llvm::make_unique<RustCast>(std::move(type), std::move(term));`
	`1803`	`+ term = std::make_unique<RustCast>(std::move(type), std::move(term));`
`1804`	`1804`	`break;`
`1805`	`1805`	`}`
`1806`	`1806`
`@@ -1952,7 +1952,7 @@ RustExpressionUP Parser::Binary(Status &error) {`
`1952`	`1952`	`switch (top.op) {`
`1953`	`1953`	`#define DEFINE(Token, Prec, Type) \`
`1954`	`1954`	`case Token: \`
`1955`		`- lhs.term = llvm::make_unique<Type>(std::move(lhs.term), std::move(top.term)); \`
	`1955`	`+ lhs.term = std::make_unique<Type>(std::move(lhs.term), std::move(top.term)); \`
`1956`	`1956`	`break;`
`1957`	`1957`
`1958`	`1958`	`BINARY_OPERATORS`
`@@ -1998,7 +1998,7 @@ RustExpressionUP Parser::Range(Status &error) {`
`1998`	`1998`	`}`
`1999`	`1999`	`}`
`2000`	`2000`
`2001`		`- return llvm::make_unique<RustRangeExpression>(std::move(lhs), std::move(rhs), is_inclusive);`
	`2001`	`+ return std::make_unique<RustRangeExpression>(std::move(lhs), std::move(rhs), is_inclusive);`
`2002`	`2002`	`}`
`2003`	`2003`
`2004`	`2004`	`////////////////////////////////////////////////////////////////`
`@@ -2033,7 +2033,7 @@ RustTypeExpressionUP Parser::ArrayType(Status &error) {`
`2033`	`2033`	`}`
`2034`	`2034`	`Advance();`
`2035`	`2035`
`2036`		`- return llvm::make_unique<RustArrayTypeExpression>(std::move(element), len);`
	`2036`	`+ return std::make_unique<RustArrayTypeExpression>(std::move(element), len);`
`2037`	`2037`	`}`
`2038`	`2038`
`2039`	`2039`	`RustTypeExpressionUP Parser::ReferenceType(Status &error) {`
`@@ -2064,10 +2064,10 @@ RustTypeExpressionUP Parser::ReferenceType(Status &error) {`
`2064`	`2064`	`}`
`2065`	`2065`	`Advance();`
`2066`	`2066`
`2067`		`- return llvm::make_unique<RustSliceTypeExpression>(std::move(target), is_mut);`
	`2067`	`+ return std::make_unique<RustSliceTypeExpression>(std::move(target), is_mut);`
`2068`	`2068`	`}`
`2069`	`2069`
`2070`		`- return llvm::make_unique<RustPointerTypeExpression>(std::move(target), true, is_mut);`
	`2070`	`+ return std::make_unique<RustPointerTypeExpression>(std::move(target), true, is_mut);`
`2071`	`2071`	`}`
`2072`	`2072`
`2073`	`2073`	`RustTypeExpressionUP Parser::PointerType(Status &error) {`
`@@ -2088,7 +2088,7 @@ RustTypeExpressionUP Parser::PointerType(Status &error) {`
`2088`	`2088`	`return target;`
`2089`	`2089`	`}`
`2090`	`2090`
`2091`		`- return llvm::make_unique<RustPointerTypeExpression>(std::move(target), false, is_mut);`
	`2091`	`+ return std::make_unique<RustPointerTypeExpression>(std::move(target), false, is_mut);`
`2092`	`2092`	`}`
`2093`	`2093`
`2094`	`2094`	`bool Parser::TypeList(std::vector<RustTypeExpressionUP> *type_list, Status &error) {`
`@@ -2174,7 +2174,7 @@ RustTypeExpressionUP Parser::FunctionType(Status &error) {`
`2174`	`2174`	`return return_type;`
`2175`	`2175`	`}`
`2176`	`2176`
`2177`		`- return llvm::make_unique<RustFunctionTypeExpression>(std::move(return_type),`
	`2177`	`+ return std::make_unique<RustFunctionTypeExpression>(std::move(return_type),`
`2178`	`2178`	`std::move(type_list));`
`2179`	`2179`	`}`
`2180`	`2180`
`@@ -2188,7 +2188,7 @@ RustTypeExpressionUP Parser::TupleType(Status &error) {`
`2188`	`2188`	`return RustTypeExpressionUP();`
`2189`	`2189`	`}`
`2190`	`2190`
`2191`		`- return llvm::make_unique<RustTupleTypeExpression>(std::move(type_list));`
	`2191`	`+ return std::make_unique<RustTupleTypeExpression>(std::move(type_list));`
`2192`	`2192`	`}`
`2193`	`2193`
`2194`	`2194`	`RustTypeExpressionUP Parser::TypePath(Status &error) {`
`@@ -2249,9 +2249,9 @@ RustTypeExpressionUP Parser::TypePath(Status &error) {`
`2249`	`2249`	`return RustTypeExpressionUP();`
`2250`	`2250`	`}`
`2251`	`2251`
`2252`		`- RustPathUP name_path = llvm::make_unique<RustPath>(saw_self, relative, supers, std::move(path),`
	`2252`	`+ RustPathUP name_path = std::make_unique<RustPath>(saw_self, relative, supers, std::move(path),`
`2253`	`2253`	`std::move(type_list));`
`2254`		`- return llvm::make_unique<RustPathTypeExpression>(std::move(name_path));`
	`2254`	`+ return std::make_unique<RustPathTypeExpression>(std::move(name_path));`
`2255`	`2255`	`}`
`2256`	`2256`
`2257`	`2257`	`RustTypeExpressionUP Parser::Type(Status &error) {`