Use slang- prefix on slang compiler and core source (#973)

* Prefixing source files in source/slang with slang-

* Prefix source in source/slang with slang- prefix.

* Rename core source files with slang- prefix.

* Update project files.

* Fix problems from automatic merge.

1 files changed, 0 insertions, 261 deletions

diff --git a/source/slang/ir-restructure.h b/source/slang/ir-restructure.h
deleted file mode 100644
index d27f7dbc8..000000000
--- a/source/slang/ir-restructure.h
+++ /dev/null
@@ -1,261 +0,0 @@
-// ir-restructure.h
-#pragma once
-
-#include "../core/basic.h"
-
-namespace Slang
-{
-    class DiagnosticSink;
-    struct IRBlock;
-    struct IRGlobalValueWithCode;
-    struct IRInst;
-    struct IRLoop;
-
-    /// A structured control-flow region.
-    ///
-    /// A `Region` is used to layer structured control flow information
-    /// over an existing IR control flow graph (CFG). Each `Region`
-    /// represents a sub-graph of the CFG such that control always
-    /// enters at the start of the region.
-    ///
-    class Region : public RefObject
-    {
-    public:
-        enum class Flavor
-        {
-            Simple,
-            If,
-            Break,
-            Continue,
-            Loop,
-            Switch,
-        };
-
-        Flavor getFlavor() { return flavor; }
-
-        Region* getParent() { return parent; }
-
-        /// Is this region a descendent of `other`?
-        ///
-        /// For the purpose of this query, a region
-        /// is a descendent of itself.
-        bool isDescendentOf(Region* other);
-
-        /// Is this region a descendent of `block`?
-        ///
-        /// This tests is the region is a descendent
-        /// of any simple region for `block`.
-        bool isDescendentOf(IRBlock* block);
-
-    protected:
-        Region(Flavor flavor, Region* parent)
-            : flavor(flavor)
-            , parent(parent)
-        {}
-
-        /// What kind of region is this?
-        Flavor flavor;
-
-        /// The parent region of this region.
-        Region* parent;
-    };
-
-    /// Base type for regions that have a "next" region.
-    ///
-    /// While we think of it as a region to execute
-    /// after this region, the `nextRegion` is actually
-    /// a *child* region, in that it can see local
-    /// values that were defined in this parent region
-    /// (and any other ancestor regions).
-    class SeqRegion : public Region
-    {
-    protected:
-        SeqRegion(Flavor flavor, Region* parent)
-            : Region(flavor, parent)
-        {}
-
-    public:
-        /// The (child) region to execute after this one.
-        RefPtr<Region> nextRegion;
-    };
-
-    /// A simple region that encapsulates a basic block.
-    ///
-    class SimpleRegion : public SeqRegion
-    {
-    public:
-        SimpleRegion(Region* parent, IRBlock* block)
-            : SeqRegion(Region::Flavor::Simple, parent)
-            , block(block)
-        {}
-
-        /// The basic block for this region.
-        IRBlock*    block = nullptr;
-
-        /// The next simple region for the same block
-        ///
-        /// A single IR basic block may turn into multiple regions,
-        /// if the restructuring pass has to duplicate it (this
-        /// currently happens for the continue clause in a `for`
-        /// loop if it has multiple `continue` sites.
-        ///
-        SimpleRegion* nextSimpleRegionForSameBlock = nullptr;
-    };
-
-    /// A conditional region, corresponding to an `if`
-    ///
-    class IfRegion : public SeqRegion
-    {
-    public:
-        IfRegion(Region* parent, IRInst* condition)
-            : SeqRegion(Region::Flavor::If, parent)
-            , condition(condition)
-        {}
-
-        /// The IR value that controls the conditional branch
-        IRInst* condition;
-
-        /// The region to execute if the `condition` is `true`
-        RefPtr<Region> thenRegion;
-
-        /// The region to execute if the `condition` is `false`
-        RefPtr<Region> elseRegion;
-    };
-
-    /// Base type for regions that execution can `break` out of
-    class BreakableRegion : public SeqRegion
-    {
-    protected:
-        BreakableRegion(Flavor flavor, Region* parent)
-            : SeqRegion(flavor, parent)
-        {}
-    };
-
-    /// A region that expresses a `break` out of nested control flow.
-    ///
-    class BreakRegion : public Region
-    {
-    public:
-        BreakRegion(Region* parent, BreakableRegion* outerRegion)
-            : Region(Region::Flavor::Break, parent)
-            , outerRegion(outerRegion)
-        {}
-
-        BreakableRegion* outerRegion;
-    };
-
-    /// A structured loop
-    class LoopRegion : public BreakableRegion
-    {
-    public:
-        LoopRegion(Region* parent, IRLoop* loopInst)
-            : BreakableRegion(Region::Flavor::Loop, parent)
-            , loopInst(loopInst)
-        {}
-
-        /// The IR instruction that represents the branch into the loop.
-        /// We keep this instruction around because it may have decorations
-        /// that need to influence how we emit this loop.
-        ///
-        IRLoop* loopInst;
-
-        /// The code inside the loop.
-        ///
-        /// The body region may include `break` or `continue` operations for this loop.
-        RefPtr<Region> body;
-    };
-
-    /// A region that expresses a `continue` for a structured loop.
-    ///
-    class ContinueRegion : public Region
-    {
-    public:
-        ContinueRegion(Region* parent, LoopRegion* outerRegion)
-            : Region(Region::Flavor::Continue, parent)
-            , outerRegion(outerRegion)
-        {}
-
-        LoopRegion* outerRegion;
-    };
-
-    /// A structured `switch` statement.
-    class SwitchRegion : public BreakableRegion
-    {
-    public:
-         SwitchRegion(Region* parent, IRInst* condition)
-            : BreakableRegion(Region::Flavor::Switch, parent)
-            , condition(condition)
-        {}
-
-        /// The IR value that controls the conditional branch
-        IRInst* condition;
-
-        /// A collection of `case`s that share the same code.
-        class Case : public RefObject
-        {
-        public:
-            /// The various values that should branch to this case.
-            ///
-            /// It is possible for this list to be empty if this
-            /// is the `default` case and has no explicit values
-            /// that map to it.
-            ///
-            List<IRInst*>   values;
-
-            /// The region to execute if this case is selected.
-            RefPtr<Region>  body;
-        };
-
-        /// All of the cases for the `switch`.
-        ///
-        /// This includes any `default` cases.
-        ///
-        /// As an invariant, a case that "falls through" to another
-        /// should immediately precede its target in this list.
-        ///
-        List<RefPtr<Case>> cases;
-
-        /// The default case, if any.
-        ///
-        /// It is valid for this to be `null` if there is no `default` case,
-        /// in which case the default behavior should be to branch to the region
-        /// after the `switch`.
-        ///
-        /// The default case must also be present in `cases`.
-        Case* defaultCase;
-    };
-
-    /// Container for all of the regions in a function.
-    ///
-    /// A `RegionTree` owns the `Region` objects associated with a function,
-    /// along with a mapping from basic blocks in the IR function to regions
-    /// in the tree.
-    ///
-    class RegionTree : public RefObject
-    {
-    public:
-        /// Type for the mapping from IR blocks to regions.
-        typedef Dictionary<IRBlock*, SimpleRegion*> MapBlockToRegion;
-
-        /// A dictionary to map from IR blocks to regions.
-        MapBlockToRegion mapBlockToRegion;
-
-        /// The root region of the region tree.
-        RefPtr<Region> rootRegion;
-
-        /// The IR function that was used to compute the region tree.
-        IRGlobalValueWithCode* irCode = nullptr;
-    };
-
-    /// Construct structrured regions to represent the control flow in an IR function.
-    ///
-    /// The resulting `RegionTree` will encode a structured (statement-like)
-    /// form for the control flow graph (CFG) of `code`.
-    /// In cases where our current restructuring approach is now powerful
-    /// enough to handle something in the input CFG, diagnostic messages
-    /// will be output to the given `sink`.
-    ///
-    RefPtr<RegionTree> generateRegionTreeForFunc(
-        IRGlobalValueWithCode*  code,
-        DiagnosticSink*         sink);
-}