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, 183 deletions

diff --git a/source/slang/ir-clone.h b/source/slang/ir-clone.h
deleted file mode 100644
index bafbfa69d..000000000
--- a/source/slang/ir-clone.h
+++ /dev/null
@@ -1,183 +0,0 @@
-// ir-clone.h
-#pragma once
-
-#include "../core/dictionary.h"
-
-#include "ir.h"
-
-namespace Slang
-{
-struct IRBuilder;
-struct IRInst;
-struct SharedIRBuilder;
-
-// This file provides an interface to simplify the task of
-// correctling "cloning" IR code, whether individual
-// instructions, or whole functions.
-
-    /// An environment for mapping existing values to their cloned replacements.
-    ///
-    /// This type serves two main roles in the process of IR cloning:
-    ///
-    /// * Before cloning begins, a client will usually
-    ///   register the mapping from things that are to be
-    ///   replaced entirely (like function parameters to
-    ///   be specialized away) to their replacements (e.g.,
-    ///   a constant value).
-    ///
-    /// * During the process of cloning, env environment
-    ///   will be maintained and updated so that when, e.g.,
-    ///   an instruction later in a function refers to
-    ///   something from earlier, we can look up the
-    ///   replacement.
-    ///
-struct IRCloneEnv
-{
-        /// A mapping from old values to their replacements.
-    Dictionary<IRInst*, IRInst*> mapOldValToNew;
-
-        /// A parent environment to fall back to if `mapOldValToNew` doesn't contain a key.
-    IRCloneEnv* parent = nullptr;
-};
-
-    /// Look up the replacement for `oldVal`, if any, registered in `env`.
-    ///
-    /// Returns `nullptr` if `oldVal` has no registered replacement.
-    ///
-IRInst* lookUp(IRCloneEnv* env, IRInst* oldVal);
-
-// The SSA property and the way we have structured
-// our "phi nodes" (block parameters) means that
-// just going through the children of a function,
-// and then the children of a block will generally
-// do the Right Thing and always visit an instruction
-// before its uses.
-//
-// The big exception to this is that branch instructions
-// can refer to blocks later in the same function.
-//
-// We work around this sort of problem in a fairly
-// general fashion, by splitting the cloning of
-// an instruction into two steps.
-//
-// The first step is just to clone the instruction
-// and its direct operands, but not any decorations
-// or children.
-
-    /// Clone `oldInst` and its direct operands.
-    ///
-    /// The "direct operands" include the type of the instruction.
-    /// The type and operands of `oldInst` will be mapped to now
-    /// values using `findOrCloneOperand` with the given `env`.
-    ///
-    /// Any new instruction that gets emitted will be output to
-    /// the provided `builder`, which must be non-null.
-    ///
-    /// This operation does *not* clone any children or decorations on `oldInst`.
-    /// This operation does *not* register its result as a replacement
-    /// for `oldInst` in the given `env`.
-    ///
-IRInst* cloneInstAndOperands(
-    IRCloneEnv*     env,
-    IRBuilder*      builder,
-    IRInst*         oldInst);
-
-// The second phase of cloning an instruction is to clone
-// its decorations and children. This step only needs to
-// be performed on those instructions that *have* decorations
-// and/or children.
-
-    /// Clone any decorations and/or children of `oldInst` onto `newInst`
-    ///
-    /// Any new instructions that get emitted will use the
-    /// provided `sharedBuilder`, which must be non-null.
-    ///
-    /// During the process of cloning decorations/children, operand values
-    /// will be looked up in the provided `env`, which should provide
-    /// replacement values for instructions that should have a different
-    /// identity in the clone.
-    /// The provided `env` will *not* be updated/modified during the
-    /// process of cloding decorations/children.
-    ///
-    /// If any child or decoration on `oldInst` already has a replacement
-    /// registered in `env`, it will *not* be cloned into `newInst`.
-    ///
-void cloneInstDecorationsAndChildren(
-    IRCloneEnv*         env,
-    SharedIRBuilder*    sharedBuilder,
-    IRInst*             oldInst,
-    IRInst*             newInst);
-
-// For the case where the user knows the sequencing constraints
-// on cloning operands before uses can be satisfied, we provide
-// a convenience wrapper around the two phases of cloning:
-
-    /// Clone `oldInst` and return the cloned value.
-    ///
-    /// This function is a convenience wrapper around
-    /// `cloneInstAndOperands` and `cloneInstDecorationsAndChildren`.
-    /// It also registers the resultint instruction as
-    /// the replacement value for `oldInst` in the given `env`
-    /// which must therefore be non-null.
-    ///
-IRInst* cloneInst(
-    IRCloneEnv*     env,
-    IRBuilder*      builder,
-    IRInst*         oldInst);
-
-    /// Clone `oldDecoration` and attach the clone to `newParent`.
-    ///
-    /// Uses `module` to allocate any new instructions.
-    ///
-void cloneDecoration(
-    IRDecoration*   oldDecoration,
-    IRInst*         newParent,
-    IRModule*       module);
-
-    /// Clone `oldDecoration` and attach the clone to `newParent`.
-    ///
-    /// Uses the module of `newParent` to allocate any new instructions,
-    /// so that `newParent` must already be installed somewhere
-    /// in the ownership hierarchy of an existing module.
-    ///
-void cloneDecoration(
-    IRDecoration*   oldDecoration,
-    IRInst*         newParent);
-
-
-    /// Find the "cloned" value to use for an operand.
-    ///
-    /// This either returns the value registered for `oldOperand`
-    /// in `env`, or else `oldOperand` itself.
-IRInst* findCloneForOperand(
-    IRCloneEnv*     env,
-    IRInst*         oldOperand);
-
-// It isn't technically part of the cloning infrastructure,
-// but when make specialized copies of IR instructions via
-// cloning we often need a simple kind of key suitable
-// for caching existing specializations, so we'll define
-// it here so that is is easily accessible to code that
-// needs it.
-
-struct IRSimpleSpecializationKey
-{
-    // The structure of a specialization key will be a list
-    // of instructions, typically starting with the function,
-    // generic, or other object to be specialized, and then
-    // having one or more entries to represent the specialization
-    // arguments.
-    //
-    List<IRInst*> vals;
-
-    // In order to use this type as a `Dictionary` key we
-    // need it to support equality and hashing.
-    //
-    // TODO: honestly we might consider having `GetHashCode`
-    // and `operator==` defined for `List<T>`.
-
-    bool operator==(IRSimpleSpecializationKey const& other) const;
-    int GetHashCode() const;
-};
-
-}