String/List closer to conventions, and use Index type (#959)

* List made members m_
Tweaked types to closer match conventions.

* Use asserts for checking conditions on List.
Other small improvements.

* List<T>.Count() -> getSize()

* List<T>
Add -> add
First -> getFirst
Last -> getLast
RemoveLast -> removeLast
ReleaseBuffer -> detachBuffer
GetArrayView -> getArrayView

* List<T>::
AddRange -> addRange
Capacity -> getCapacity
Insert -> insert
InsertRange -> insertRange
AddRange -> addRange
RemoveRange -> removeRange
RemoveAt -> removeAt
Remove -> remove
Reverse -> reverse
FastRemove -> fastRemove
FastRemoveAt -> fastRemoveAt
Clear -> clear

* List<T>
FreeBuffer -> _deallocateBuffer
Free -> clearAndDeallocate
SwapWith -> swapWith

* List<T>
SetSize -> setSize
Reserve -> reserve
GrowToSize growToSize

* UnsafeShrinkToSize -> unsafeShrinkToSize
Compress -> compress
FindLast -> findLastIndex
FindLast -> findLastIndex
Simplify Contains

* List<T>
Removed m_allocator (wasn't used)
Swap -> swapElements
Sort -> sort
Contains -> contains
ForEach -> forEach
QuickSort -> quickSort
InsertionSort -> insertionSort
BinarySearch -> binarySearch

Max -> calcMax
Min -> calcMin

* Initializer::Initialize -> initialize
List<T>::
Allocate -> _allocate
Init -> _init
IndexOf -> indexOf

* * Put #include <assert.h> in common.h, and remove unneeded inclusions
* Small refactor of ArrayView - remove stride as not used

* getSize -> getCount
setSize -> setCount
unsafeShrinkToSize->unsafeShrinkToCount
growToSize -> growToCount
m_size -> m_count

* Some tidy up around Allocator.

* Use Index type on List.

* Refactor of IntSet.
First tentative look at using Index.

* Made Index an Int
Did preliminary fixes.
Made String use Index.

* Partial refactor of String.

* String::Buffer -> getBuffer
ToWString -> toWString

* Small improvements to String.
String::
Buffer() -> getBuffer()
Equals() -> equals

* Try to use Index where appropriate.

* Fix warnings on windows x86 builds.

1 files changed, 26 insertions, 26 deletions

diff --git a/source/slang/parser.cpp b/source/slang/parser.cpp
index a6063a2a9..825aea324 100644
--- a/source/slang/parser.cpp
+++ b/source/slang/parser.cpp
@@ -735,7 +735,7 @@ namespace Slang
                     auto arg = parser->ParseArgExpr();
                     if (arg)
                     {
-                        modifier->args.Add(arg);
+                        modifier->args.add(arg);
                     }
 
                     if (AdvanceIfMatch(parser, TokenType::RParent))
@@ -1075,7 +1075,7 @@ namespace Slang
         if (container)
         {
             member->ParentDecl = container.Ptr();
-            container->Members.Add(member);
+            container->Members.add(member);
 
             container->memberDictionaryIsValid = false;
         }
@@ -1597,13 +1597,13 @@ namespace Slang
             {
                 group = new DeclGroup();
                 group->loc = startPosition;
-                group->decls.Add(decl);
+                group->decls.add(decl);
                 decl = nullptr;
             }
 
             if( group )
             {
-                group->decls.Add(newDecl);
+                group->decls.add(newDecl);
             }
             else
             {
@@ -1662,10 +1662,10 @@ namespace Slang
         parser->ReadToken(TokenType::OpLess);
         parser->genericDepth++;
         // For now assume all generics have at least one argument
-        genericApp->Arguments.Add(ParseGenericArg(parser));
+        genericApp->Arguments.add(ParseGenericArg(parser));
         while (AdvanceIf(parser, TokenType::Comma))
         {
-            genericApp->Arguments.Add(ParseGenericArg(parser));
+            genericApp->Arguments.add(ParseGenericArg(parser));
         }
         parser->genericDepth--;
 
@@ -1778,7 +1778,7 @@ namespace Slang
         while(!AdvanceIfMatch(parser, TokenType::RParent))
         {
             auto caseType = parser->ParseTypeExp();
-            taggedUnionType->caseTypes.Add(caseType);
+            taggedUnionType->caseTypes.add(caseType);
 
             if(AdvanceIf(parser, TokenType::RParent))
                 break;
@@ -2258,7 +2258,7 @@ namespace Slang
         bufferDataTypeExpr->name = bufferDataTypeDecl->nameAndLoc.name;
         bufferDataTypeExpr->scope = parser->currentScope.Ptr();
 
-        // Construct a type exrpession to reference the type constructor
+        // Construct a type expression to reference the type constructor
         auto bufferWrapperTypeExpr = new VarExpr();
         bufferWrapperTypeExpr->loc = bufferWrapperTypeNamePos;
         bufferWrapperTypeExpr->name = getName(parser, bufferWrapperTypeName);
@@ -2272,11 +2272,11 @@ namespace Slang
         auto bufferVarTypeExpr = new GenericAppExpr();
         bufferVarTypeExpr->loc = bufferVarDecl->loc;
         bufferVarTypeExpr->FunctionExpr = bufferWrapperTypeExpr;
-        bufferVarTypeExpr->Arguments.Add(bufferDataTypeExpr);
+        bufferVarTypeExpr->Arguments.add(bufferDataTypeExpr);
 
         bufferVarDecl->type.exp = bufferVarTypeExpr;
 
-        // Any semantics applied to the bufer declaration are taken as applying
+        // Any semantics applied to the buffer declaration are taken as applying
         // to the variable instead.
         ParseOptSemantics(parser, bufferVarDecl.Ptr());
 
@@ -2943,7 +2943,7 @@ namespace Slang
         }
         else if( auto declGroup = as<DeclGroup>(declBase) )
         {
-            if( declGroup->decls.Count() == 1 )
+            if( declGroup->decls.getCount() == 1 )
             {
                 return declGroup->decls[0];
             }
@@ -3340,14 +3340,14 @@ namespace Slang
                 }
                 else if (auto seqStmt = as<SeqStmt>(body))
                 {
-                    seqStmt->stmts.Add(stmt);
+                    seqStmt->stmts.add(stmt);
                 }
                 else
                 {
                     RefPtr<SeqStmt> newBody = new SeqStmt();
                     newBody->loc = blockStatement->loc;
-                    newBody->stmts.Add(body);
-                    newBody->stmts.Add(stmt);
+                    newBody->stmts.add(body);
+                    newBody->stmts.add(stmt);
 
                     body = newBody;
                 }
@@ -3668,8 +3668,8 @@ namespace Slang
         RefPtr<InfixExpr> expr = new InfixExpr();
         expr->loc = op->loc;
         expr->FunctionExpr = op;
-        expr->Arguments.Add(left);
-        expr->Arguments.Add(right);
+        expr->Arguments.add(left);
+        expr->Arguments.add(right);
         return expr;
     }
 
@@ -3696,11 +3696,11 @@ namespace Slang
                 select->loc = op->loc;
                 select->FunctionExpr = op;
 
-                select->Arguments.Add(expr);
+                select->Arguments.add(expr);
 
-                select->Arguments.Add(parser->ParseExpression(opPrec));
+                select->Arguments.add(parser->ParseExpression(opPrec));
                 parser->ReadToken(TokenType::Colon);
-                select->Arguments.Add(parser->ParseExpression(opPrec));
+                select->Arguments.add(parser->ParseExpression(opPrec));
 
                 expr = select;
                 continue;
@@ -3855,7 +3855,7 @@ namespace Slang
         //
         // Proper disambiguation requires mixing up parsing
         // and semantic checking (which we should do eventually)
-        // but for now we will follow some hueristics.
+        // but for now we will follow some heuristics.
         case TokenType::LParent:
             {
                 Token openParen = parser->ReadToken(TokenType::LParent);
@@ -3868,7 +3868,7 @@ namespace Slang
                     parser->ReadToken(TokenType::RParent);
 
                     auto arg = parsePrefixExpr(parser);
-                    tcexpr->Arguments.Add(arg);
+                    tcexpr->Arguments.add(arg);
 
                     return tcexpr;
                 }
@@ -3903,7 +3903,7 @@ namespace Slang
                     auto expr = parser->ParseArgExpr();
                     if( expr )
                     {
-                        initExpr->args.Add(expr);
+                        initExpr->args.add(expr);
                     }
 
                     if(AdvanceIfMatch(parser, TokenType::RBrace))
@@ -4150,7 +4150,7 @@ namespace Slang
                     RefPtr<OperatorExpr> postfixExpr = new PostfixExpr();
                     parser->FillPosition(postfixExpr.Ptr());
                     postfixExpr->FunctionExpr = parseOperator(parser);
-                    postfixExpr->Arguments.Add(expr);
+                    postfixExpr->Arguments.add(expr);
 
                     expr = postfixExpr;
                 }
@@ -4184,7 +4184,7 @@ namespace Slang
                     while (!parser->tokenReader.IsAtEnd())
                     {
                         if (!parser->LookAheadToken(TokenType::RParent))
-                            invokeExpr->Arguments.Add(parser->ParseArgExpr());
+                            invokeExpr->Arguments.add(parser->ParseArgExpr());
                         else
                         {
                             break;
@@ -4259,7 +4259,7 @@ namespace Slang
                 RefPtr<PrefixExpr> prefixExpr = new PrefixExpr();
                 parser->FillPosition(prefixExpr.Ptr());
                 prefixExpr->FunctionExpr = parseOperator(parser);
-                prefixExpr->Arguments.Add(parsePrefixExpr(parser));
+                prefixExpr->Arguments.add(parsePrefixExpr(parser));
                 return prefixExpr;
             }
             break;
@@ -4566,7 +4566,7 @@ namespace Slang
         while( AdvanceIf(parser, TokenType::Comma) )
         {
             auto operand = uint32_t(StringToInt(parser->ReadToken(TokenType::IntegerLiteral).Content));
-            modifier->irOperands.Add(operand);
+            modifier->irOperands.add(operand);
         }
         parser->ReadToken(TokenType::RParent);