Update namespaces

Build.proj

@@ -75,7 +75,7 @@
     </ItemGroup>
     <Copy DestinationFolder="$(StageDir)" SourceFiles="@(InfoFiles)" />
     <ItemGroup>
-      <AssemblyFiles Include="$(BinDir)\$(Configuration)\**\Microsoft.Scripting.*;$(BinDir)\$(Configuration)\**\Microsoft.Dynamic.*" Exclude="$(BinDir)\$(Configuration)\**\Microsoft.*.Test.*" />
+      <AssemblyFiles Include="$(BinDir)\$(Configuration)\**\Riverside.Scripting.*;$(BinDir)\$(Configuration)\**\Riverside.Dynamic.*" Exclude="$(BinDir)\$(Configuration)\**\Riverside.*.Test.*" />
     </ItemGroup>
     <Copy DestinationFolder="$(StageDir)\%(RecursiveDir)" SourceFiles="@(AssemblyFiles)" />
   </Target>

Directory.Build.props

@@ -4,7 +4,7 @@
 
   <PropertyGroup>
     <DlrRootDir>$(MSBuildThisFileDirectory)</DlrRootDir>
-    <DlrBuildDir>$(DlrRootDir)\Build</DlrBuildDir>
+    <DlrBuildDir>$(DlrRootDir)\Packaging\Targets</DlrBuildDir>
 
     <!-- The following two lines prevent csc.rsp and Microsoft.NETFramework.props from adding additional assembly references -->
     <NoConfig>true</NoConfig>
@@ -16,8 +16,8 @@
     <AssemblyFileRevision Condition="'$(ReleaseLevel)' == 'final'">1000</AssemblyFileRevision>
 
     <Product>Dynamic Language Runtime</Product>
-    <Company>DLR Open Source Team</Company>
-    <Copyright>© DLR Contributors</Copyright>
+    <Company>Riverside Valley Corporation</Company>
+    <Copyright>© .NET Foundation and Contributors</Copyright>
     <AssemblyVersion>$(MajorVersion).$(MinorVersion).$(MicroVersion).$(AssemblyRevision)</AssemblyVersion>
     <FileVersion>$(MajorVersion).$(MinorVersion).$(MicroVersion).$(AssemblyFileRevision)</FileVersion>
     <InformationalVersion>$(MSBuildProjectName) $(MajorVersion).$(MinorVersion).$(MicroVersion) $(ReleaseLevel) $(ReleaseSerial)</InformationalVersion>

Dynamic.sln

@@ -10,11 +10,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ClrAssembly", "Tests\ClrAss
 		{EB66B766-6354-4208-A3D4-AACBDCB5C3B3} = {EB66B766-6354-4208-A3D4-AACBDCB5C3B3}
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Dynamic", "Dynamic\Microsoft.Dynamic.csproj", "{EB66B766-6354-4208-A3D4-AACBDCB5C3B3}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Riverside.Dynamic", "Dynamic\Riverside.Dynamic.csproj", "{EB66B766-6354-4208-A3D4-AACBDCB5C3B3}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Scripting", "Scripting\Microsoft.Scripting.csproj", "{02FF0909-F5AD-48CF-A86A-345E721B7E40}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Riverside.Scripting", "Scripting\Riverside.Scripting.csproj", "{02FF0909-F5AD-48CF-A86A-345E721B7E40}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Scripting.Metadata", "Metadata\Microsoft.Scripting.Metadata.csproj", "{ACDD9B9E-8FE6-439C-9521-1CCBA47F6143}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Riverside.Scripting.Metadata", "Metadata\Riverside.Scripting.Metadata.csproj", "{ACDD9B9E-8FE6-439C-9521-1CCBA47F6143}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Metadata", "Tests\Metadata\Metadata.csproj", "{848BBEB0-63E6-4736-B60C-23A9D733593D}"
 EndProject
@@ -49,9 +49,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "nuget", "nuget", "{88E65B67
 		Package\nuget\DynamicLanguageRuntime.nuspec = Package\nuget\DynamicLanguageRuntime.nuspec
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Dynamic.Test", "Tests\Microsoft.Dynamic.Test\Microsoft.Dynamic.Test.csproj", "{CBDDAD40-D44E-458A-AA53-9A6DB62EC4A1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Riverside.Dynamic.Test", "Tests\Riverside.Dynamic.Test\Riverside.Dynamic.Test.csproj", "{CBDDAD40-D44E-458A-AA53-9A6DB62EC4A1}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Scripting.Test", "Tests\Microsoft.Scripting.Test\Microsoft.Scripting.Test.csproj", "{56B4AA3A-42BC-4CA6-A022-703A777332AF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Riverside.Scripting.Test", "Tests\Riverside.Scripting.Test\Riverside.Scripting.Test.csproj", "{56B4AA3A-42BC-4CA6-A022-703A777332AF}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

Dynamic/Actions/ActionBinder.cs

@@ -9,16 +9,16 @@
 using System.Linq.Expressions;
 using System.Reflection;
 
-using Microsoft.Scripting.Actions.Calls;
-using Microsoft.Scripting.Generation;
-using Microsoft.Scripting.Runtime;
-using Microsoft.Scripting.Utils;
-using AstUtils = Microsoft.Scripting.Ast.Utils;
+using Riverside.Scripting.Actions.Calls;
+using Riverside.Scripting.Generation;
+using Riverside.Scripting.Runtime;
+using Riverside.Scripting.Utils;
+using AstUtils = Riverside.Scripting.Ast.Utils;
 
-namespace Microsoft.Scripting.Actions {
+namespace Riverside.Scripting.Actions {
     /// <summary>
     /// Provides binding semantics for a language.  This include conversions as well as support
-    /// for producing rules for actions.  These optimized rules are used for calling methods, 
+    /// for producing rules for actions.  These optimized rules are used for calling methods,
     /// performing operators, and getting members using the ActionBinder's conversion semantics.
     /// </summary>
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling")]
@@ -27,7 +27,7 @@ public abstract class ActionBinder {
 
         /// <summary>
         /// Determines if the binder should allow access to non-public members.
-        /// 
+        ///
         /// By default the binder does not allow access to non-public members.  Base classes
         /// can inherit and override this value to customize whether or not private binding
         /// is available.
@@ -105,7 +105,7 @@ public virtual Expression ConvertExpression(Expression expr, Type toType, Conver
 
         /// <summary>
         /// Gets the members that are visible from the provided type of the specified name.
-        /// 
+        ///
         /// The default implemetnation first searches the type, then the flattened heirachy of the type, and then
         /// registered extension methods.
         /// </summary>
@@ -186,7 +186,7 @@ public ErrorInfo MakeStaticPropertyInstanceAccessError(PropertyTracker tracker,
 
         /// <summary>
         /// Called when a set is attempting to assign to a field or property from a derived class through the base class.
-        /// 
+        ///
         /// The default behavior is to allow the assignment.
         /// </summary>
         public virtual ErrorInfo MakeStaticAssignFromDerivedTypeError(Type accessingType, DynamicMetaObject self, MemberTracker assigning, DynamicMetaObject assignedValue, OverloadResolverFactory context) {
@@ -220,7 +220,7 @@ public virtual ErrorInfo MakeStaticAssignFromDerivedTypeError(Type accessingType
 
         /// <summary>
         /// Creates an ErrorInfo object when a static property is accessed from an instance member.  The default behavior is throw
-        /// an exception indicating that static members properties be accessed via an instance.  Languages can override this to 
+        /// an exception indicating that static members properties be accessed via an instance.  Languages can override this to
         /// customize the exception, message, or to produce an ErrorInfo object which reads or writes to the property being accessed.
         /// </summary>
         /// <param name="tracker">The static property being accessed through an instance</param>
@@ -270,7 +270,7 @@ public virtual ErrorInfo MakeConversionError(Type toType, Expression value) {
         /// <summary>
         /// Provides a way for the binder to provide a custom error message when lookup fails.  Just
         /// doing this for the time being until we get a more robust error return mechanism.
-        /// 
+        ///
         /// Deprecated, use the non-generic version instead
         /// </summary>
         public virtual ErrorInfo MakeMissingMemberError(Type type, DynamicMetaObject self, string name) {
@@ -295,7 +295,7 @@ public virtual ErrorInfo MakeMissingMemberErrorForDelete(Type type, DynamicMetaO
         }
 
         #endregion
-       
+
         public virtual string GetTypeName(Type t) {
             return t.Name;
         }
@@ -376,7 +376,7 @@ public virtual IList<Type> GetExtensionTypes(Type t) {
 
         /// <summary>
         /// Provides an opportunity for languages to replace all MemberTracker's with their own type.
-        /// 
+        ///
         /// Alternatlely a language can expose MemberTracker's directly.
         /// </summary>
         /// <param name="memberTracker">The member which is being returned to the user.</param>

Dynamic/Actions/Argument.cs

@@ -5,10 +5,10 @@
 using System;
 using System.Linq.Expressions;
 
-using Microsoft.Scripting.Utils;
-using AstUtils = Microsoft.Scripting.Ast.Utils;
+using Riverside.Scripting.Utils;
+using AstUtils = Riverside.Scripting.Ast.Utils;
 
-namespace Microsoft.Scripting.Actions {
+namespace Riverside.Scripting.Actions {
     /// <summary>
     /// TODO: Alternatively, it should be sufficient to remember indices for this, list, dict and block.
     /// </summary>

Dynamic/Actions/ArgumentType.cs

@@ -2,12 +2,12 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
-namespace Microsoft.Scripting.Actions {
+namespace Riverside.Scripting.Actions {
     /// <summary>
     /// Convention for an individual argument at a callsite.
-    /// 
-    /// Multiple different callsites can match against a single declaration. 
-    /// Some argument kinds can be "unrolled" into multiple arguments, such as list and dictionary. 
+    ///
+    /// Multiple different callsites can match against a single declaration.
+    /// Some argument kinds can be "unrolled" into multiple arguments, such as list and dictionary.
     /// </summary>
     public enum ArgumentType {
         /// <summary>
@@ -23,7 +23,7 @@ public enum ArgumentType {
         Named,
 
         /// <summary>
-        /// Argument containing a list of arguments. 
+        /// Argument containing a list of arguments.
         /// In Python: foo(*(1,2*2,3))  would match 'def foo(a,b,c)' with 3 declared arguments such that (a,b,c)=(1,4,3).
         ///      it could also match 'def foo(*l)' with 1 declared argument such that l=(1,4,3)
         /// </summary>

Dynamic/Actions/BoundMemberTracker.cs

@@ -5,9 +5,9 @@
 using System;
 using System.Dynamic;
 
-using Microsoft.Scripting.Actions.Calls;
+using Riverside.Scripting.Actions.Calls;
 
-namespace Microsoft.Scripting.Actions {
+namespace Riverside.Scripting.Actions {
     public class BoundMemberTracker : MemberTracker {
         public BoundMemberTracker(MemberTracker tracker, DynamicMetaObject instance) {
             BoundTo = tracker;

Dynamic/Actions/CallSignature.cs

@@ -8,17 +8,17 @@
 using System.Linq.Expressions;
 using System.Text;
 
-using Microsoft.Scripting.Generation;
-using Microsoft.Scripting.Utils;
-using AstUtils = Microsoft.Scripting.Ast.Utils;
+using Riverside.Scripting.Generation;
+using Riverside.Scripting.Utils;
+using AstUtils = Riverside.Scripting.Ast.Utils;
 
-namespace Microsoft.Scripting.Actions {
+namespace Riverside.Scripting.Actions {
     /// <summary>
     /// Richly represents the signature of a callsite.
     /// </summary>
     public struct CallSignature : IEquatable<CallSignature> {
         // TODO: invariant _infos != null ==> _argumentCount == _infos.Length
-        
+
         /// <summary>
         /// Array of additional meta information about the arguments, such as named arguments.
         /// Null for a simple signature that's just an expression list. eg: foo(a*b,c,d)
@@ -31,14 +31,14 @@ public struct CallSignature : IEquatable<CallSignature> {
         private readonly int _argumentCount;
 
         /// <summary>
-        /// All arguments are unnamed and matched by position. 
+        /// All arguments are unnamed and matched by position.
         /// </summary>
         public bool IsSimple => _infos == null;
 
         public int ArgumentCount {
             get {
                 Debug.Assert(_infos == null || _infos.Length == _argumentCount);
-                return _argumentCount; 
+                return _argumentCount;
             }
         }
 
@@ -48,7 +48,7 @@ public CallSignature(CallSignature signature) {
             _infos = signature.GetArgumentInfos();
             _argumentCount = signature._argumentCount;
         }
-        
+
         public CallSignature(int argumentCount) {
             ContractUtils.Requires(argumentCount >= 0, nameof(argumentCount));
             _argumentCount = argumentCount;
@@ -135,7 +135,7 @@ public override string ToString() {
             if (_infos == null) {
                 return "Simple";
             }
-            
+
             StringBuilder sb = new StringBuilder("(");
             for (int i = 0; i < _infos.Length; i++) {
                 if (i > 0) {
@@ -174,7 +174,7 @@ public CallSignature InsertArgumentAt(int index, Argument info) {
                 if (info.IsSimple) {
                     return new CallSignature(_argumentCount + 1);
                 }
-                
+
                 return new CallSignature(ArrayUtils.InsertAt(GetArgumentInfos(), index, info));
             }
 
@@ -239,7 +239,7 @@ public bool HasKeywordArgument() {
             }
             return false;
         }
-        
+
         public ArgumentType GetArgumentKind(int index) {
             // TODO: Contract.Requires(index >= 0 && index < _argumentCount, "index");
             return _infos?[index].Kind ?? ArgumentType.Simple;
@@ -298,7 +298,7 @@ public Expression CreateExpression() {
                 args[i] = _infos[i].CreateExpression();
             }
             return Expression.New(
-                typeof(CallSignature).GetConstructor(new Type[] { typeof(Argument[]) }), 
+                typeof(CallSignature).GetConstructor(new Type[] { typeof(Argument[]) }),
                 Expression.NewArrayInit(typeof(Argument), args)
             );
         }

Dynamic/Actions/Calls/ActualArguments.cs

@@ -8,9 +8,9 @@
 using System.Dynamic;
 using System.Linq;
 
-using Microsoft.Scripting.Utils;
+using Riverside.Scripting.Utils;
 
-namespace Microsoft.Scripting.Actions.Calls {
+namespace Riverside.Scripting.Actions.Calls {
     public sealed class ActualArguments {
         public ActualArguments(IList<DynamicMetaObject> args, IList<DynamicMetaObject> namedArgs, IList<string> argNames,
             int hiddenCount, int collapsedCount, int firstSplattedArg, int splatIndex) {
@@ -74,9 +74,9 @@ internal int ToSplattedItemIndex(int collapsedArgIndex) {
             index < Arguments.Count ? Arguments[index] : NamedArguments[index - Arguments.Count];
 
         /// <summary>
-        /// Binds named arguments to the parameters. Returns a permutation of indices that captures the relationship between 
+        /// Binds named arguments to the parameters. Returns a permutation of indices that captures the relationship between
         /// named arguments and their corresponding parameters. Checks for duplicate and unbound named arguments.
-        /// Ensures that for all i: namedArgs[i] binds to parameters[args.Length + bindingPermutation[i]] 
+        /// Ensures that for all i: namedArgs[i] binds to parameters[args.Length + bindingPermutation[i]]
         /// </summary>
         internal bool TryBindNamedArguments(MethodCandidate method, out ArgumentBinding binding, out CallFailure failure) {
             if (NamedArguments.Count == 0) {

Dynamic/Actions/Calls/ApplicableCandidate.cs

@@ -2,9 +2,9 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Scripting.Utils;
+using Riverside.Scripting.Utils;
 
-namespace Microsoft.Scripting.Actions.Calls {
+namespace Riverside.Scripting.Actions.Calls {
     public sealed class ApplicableCandidate {
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
         public readonly MethodCandidate Method;

Dynamic/Actions/Calls/ArgBuilder.cs

@@ -6,11 +6,11 @@
 using System.Linq.Expressions;
 using System.Reflection;
 
-namespace Microsoft.Scripting.Actions.Calls {
+namespace Riverside.Scripting.Actions.Calls {
     /// <summary>
     /// ArgBuilder provides an argument value used by the MethodBinder.  One ArgBuilder exists for each
-    /// physical parameter defined on a method.  
-    /// 
+    /// physical parameter defined on a method.
+    ///
     /// Contrast this with ParameterWrapper which represents the logical argument passed to the method.
     /// </summary>
     public abstract class ArgBuilder {

Dynamic/Actions/Calls/ArgumentBinding.cs

@@ -2,9 +2,9 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Scripting.Utils;
+using Riverside.Scripting.Utils;
 
-namespace Microsoft.Scripting.Actions.Calls {
+namespace Riverside.Scripting.Actions.Calls {
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1815:OverrideEqualsAndOperatorEqualsOnValueTypes")] // TODO
     public struct ArgumentBinding {
         private static readonly int[] _EmptyBinding = System.Array.Empty<int>();

Dynamic/Actions/Calls/BindingResult.cs

@@ -2,13 +2,13 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
-namespace Microsoft.Scripting.Actions.Calls {
+namespace Riverside.Scripting.Actions.Calls {
     /// <summary>
     /// Indicates the specific type of failure, if any, from binding to a method.
     /// </summary>
     public enum BindingResult {
         /// <summary>
-        /// The binding succeeded.  Only one method was applicable or had the best conversion.  
+        /// The binding succeeded.  Only one method was applicable or had the best conversion.
         /// </summary>
         Success,
 
@@ -26,7 +26,7 @@ public enum BindingResult {
         /// None of the target method(s) can successfully be called.  The failure can be due to:
         ///     1. Arguments could not be successfully converted for the call
         ///     2. Keyword arguments could not be assigned to positional arguments
-        ///     3. Keyword arguments could be assigned but would result in an argument being assigned 
+        ///     3. Keyword arguments could be assigned but would result in an argument being assigned
         ///        multiple times (keyword and positional arguments conflit or dupliate keyword arguments).
         /// </summary>
         CallFailure,