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, 17 insertions, 17 deletions

diff --git a/source/slang/ir-sccp.cpp b/source/slang/ir-sccp.cpp
index 66b370848..242ef0a37 100644
--- a/source/slang/ir-sccp.cpp
+++ b/source/slang/ir-sccp.cpp
@@ -357,7 +357,7 @@ struct SCCPContext
                 // executed. We do this by adding the target to our CFG work list.
                 //
                 auto target = unconditionalBranch->getTargetBlock();
-                cfgWorkList.Add(target);
+                cfgWorkList.add(target);
 
                 // Besides transferring control to another block, the other
                 // thing our unconditional branch instructions do is provide
@@ -408,7 +408,7 @@ struct SCCPContext
                         setLatticeVal(param, newVal);
                         for( auto use = param->firstUse; use; use = use->nextUse )
                         {
-                            ssaWorkList.Add(use->getUser());
+                            ssaWorkList.add(use->getUser());
                         }
                     }
                 }
@@ -448,7 +448,7 @@ struct SCCPContext
                         // bail out now.
                         //
                         auto target = boolConst->getValue() ? conditionalBranch->getTrueBlock() : conditionalBranch->getFalseBlock();
-                        cfgWorkList.Add(target);
+                        cfgWorkList.add(target);
                         return;
                     }
                 }
@@ -459,8 +459,8 @@ struct SCCPContext
                 // taken, so that both of the target blocks are
                 // potentially executed.
                 //
-                cfgWorkList.Add(conditionalBranch->getTrueBlock());
-                cfgWorkList.Add(conditionalBranch->getFalseBlock());
+                cfgWorkList.add(conditionalBranch->getTrueBlock());
+                cfgWorkList.add(conditionalBranch->getFalseBlock());
             }
             else if( auto switchInst = as<IRSwitch>(inst) )
             {
@@ -497,7 +497,7 @@ struct SCCPContext
                         // Whatever single block we decided will get executed,
                         // we need to make sure it gets processed and then bail.
                         //
-                        cfgWorkList.Add(target);
+                        cfgWorkList.add(target);
                         return;
                     }
                 }
@@ -507,9 +507,9 @@ struct SCCPContext
                 //
                 for( UInt cc = 0; cc < caseCount; ++cc )
                 {
-                    cfgWorkList.Add(switchInst->getCaseLabel(cc));
+                    cfgWorkList.add(switchInst->getCaseLabel(cc));
                 }
-                cfgWorkList.Add(switchInst->getDefaultLabel());
+                cfgWorkList.add(switchInst->getDefaultLabel());
             }
 
             // There are other cases of terminator instructions not handled
@@ -563,7 +563,7 @@ struct SCCPContext
         //
         for( auto use = inst->firstUse; use; use = use->nextUse )
         {
-            ssaWorkList.Add(use->getUser());
+            ssaWorkList.add(use->getUser());
         }
     }
 
@@ -584,7 +584,7 @@ struct SCCPContext
         // The entry block is always going to be executed when the
         // function gets called, so we will process it right away.
         //
-        cfgWorkList.Add(firstBlock);
+        cfgWorkList.add(firstBlock);
 
         // The parameters of the first block are our function parameters,
         // and we want to operate on the assumption that they could have
@@ -597,7 +597,7 @@ struct SCCPContext
 
         // Now we will iterate until both of our work lists go dry.
         //
-        while(cfgWorkList.Count() || ssaWorkList.Count())
+        while(cfgWorkList.getCount() || ssaWorkList.getCount())
         {
             // Note: there is a design choice to be had here
             // around whether we do `if if` or `while while`
@@ -607,12 +607,12 @@ struct SCCPContext
             // We will start by processing any blocks that we
             // have determined are potentially reachable.
             //
-            while( cfgWorkList.Count() )
+            while( cfgWorkList.getCount() )
             {
                 // We pop one block off of the work list.
                 //
                 auto block = cfgWorkList[0];
-                cfgWorkList.FastRemoveAt(0);
+                cfgWorkList.fastRemoveAt(0);
 
                 // We only want to process blocks that haven't
                 // already been marked as executed, so that we
@@ -644,12 +644,12 @@ struct SCCPContext
             // will start looking at individual instructions that
             // need to be updated.
             //
-            while( ssaWorkList.Count() )
+            while( ssaWorkList.getCount() )
             {
                 // We pop one instruction that needs an update.
                 //
                 auto inst = ssaWorkList[0];
-                ssaWorkList.FastRemoveAt(0);
+                ssaWorkList.fastRemoveAt(0);
 
                 // Before updating the instruction, we will check if
                 // the parent block of the instructin is marked as
@@ -728,7 +728,7 @@ struct SCCPContext
                 inst->replaceUsesWith(constantVal);
                 if( !inst->mightHaveSideEffects() )
                 {
-                    instsToRemove.Add(inst);
+                    instsToRemove.add(inst);
                 }
             }
         }
@@ -817,7 +817,7 @@ struct SCCPContext
         {
             if( !isMarkedAsExecuted(block) )
             {
-                unreachableBlocks.Add(block);
+                unreachableBlocks.add(block);
             }
         }
         //