Major cleanup of the codebase

Author: fholm

Files/Changelogs/0.2.1.txt

@@ -7,4 +7,17 @@ John Gietzen
 ## Changelog
 
 * Exceptions of type System.Reflection.TargetInvocationException caused by a JavaScript-catchable 
-  error will no longer bubble up to the hosting code.
+  error will no longer bubble up to the hosting code.
+* Renamed the Ast.NewVars module to Ast.Utils
+* Renamed Ast.Scope to Ast.FunctionScope
+* Renamed Ast.Tree.FunctionFast to Ast.Tree.Function
+* Renamed CLR2.fs to Legacy.fs
+* Removed the ExtensionMethods module
+* Removed GlobalScopeHelper.GetGlobalNice and Compiler.Identifier.getValueNice
+* Removed the FSharpOperators module
+* Changed several types, modules, constructors, methods and functions from public to private/internal
+* Added new constructor to CommonObject that only takes two parameters (Environment and CommonObject)
+  and defaults to using the Environment.Maps.Base property schema
+* Converted Ast.GlobalScope, Ast.EvalMode and Ast.LookupMode from enums to unions
+* Added the RequireQualifiedAccess attribute to several modules and removed alot of cryptic aliases
+  to keep the code clean and easy to read

Src/CLR4.sln

@@ -26,6 +26,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Changelogs", "Changelogs",
 		..\Files\Changelogs\0.1.93.txt = ..\Files\Changelogs\0.1.93.txt
 		..\Files\Changelogs\0.1.94.txt = ..\Files\Changelogs\0.1.94.txt
 		..\Files\Changelogs\0.2.0.txt = ..\Files\Changelogs\0.2.0.txt
+		..\Files\Changelogs\0.2.1.txt = ..\Files\Changelogs\0.2.1.txt
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Scripts", "Scripts", "{39A51F96-9421-4146-B875-D704349A51F4}"

Src/IronJS/Compiler.Analyzer.fs

@@ -2,18 +2,17 @@
 
 open IronJS
 open IronJS.Compiler
-open IronJS.Compiler.Ast
 open IronJS.Compiler.Parser
 
-module Analyzer =
+module internal Analyzer =
 
   /// Tries to find a variable in a ScopeData chain
   let rec findVariable name (d:ScopeData option) =
     match d with
     | None -> None // We're past the top scope, means we didn't find anything
     | Some d ->
       match d.Scope with
-      | Catch s ->
+      | Ast.ScopeOption.Catch s ->
         // Catch scopes are simple, they only
         // contain one variable so check the name
         // and if it matches return 1 (which is the storage
@@ -24,7 +23,7 @@ module Analyzer =
           then (1, (!s).GlobalLevel) |> Some
           else d.Parent |> findVariable name
 
-      | Function s ->
+      | Ast.ScopeOption.Function s ->
         // Try to locate the variable in 
         // the current function scope
         match (!s).Variables |> Map.tryFind name with
@@ -34,36 +33,36 @@ module Analyzer =
           // original owning scope, we got everything we need
           // so just return the same values
           match var with
-          | Shared(storageIndex, globalLevel, _) ->
+          | Ast.Variable.Shared(storageIndex, globalLevel, _) ->
             (storageIndex, globalLevel) |> Some
 
           // But it can also be a private variable in the current scope
           // which means we have to turn it into a shared variable instead
-          | Private _ ->
-            s |> Ast.NewVars.promotePrivateToShared name |> Some
+          | Ast.Variable.Private _ ->
+            s |> Ast.Utils.promotePrivateToShared name |> Some
 
         | _ ->
           d.Parent |> findVariable name
 
   let rec buildVariables (d:ScopeData) =
     // First create variables in function scopes
     match d.Scope with
-    | Catch _ -> () // Don't need to do anything for catch scopes
-    | Function s ->   
+    | Ast.ScopeOption.Catch _ -> () // Don't need to do anything for catch scopes
+    | Ast.ScopeOption.Function s ->   
       match (!s).ScopeType with
-      | ScopeType.GlobalScope ->
+      | Ast.ScopeType.GlobalScope ->
         // Global scopes are easy, just copy
         // the variable set to the Globals property
         s := {!s with Globals = !d.Variables}
 
-      | ScopeType.FunctionScope ->
+      | Ast.ScopeType.FunctionScope ->
         // First, copy all parameter names to the correct property
         s := {!s with ParameterNames = !d.Parameters}
 
         // Create private variables for all
         // all variables in this scope
         for name in !d.Variables do
-          s |> NewVars.createPrivateVariable name
+          s |> Ast.Utils.createPrivateVariable name
 
         // Then step through all missing 
         // variables for this scope
@@ -74,7 +73,7 @@ module Analyzer =
             // We found a variable in the scope chain - either a previously shared
             // or one that used to be private and that was turned into a shared.
             // Create a new shared variable in this scope for the variable
-            s |> NewVars.createSharedVariable name storageIndex globalLevel |> ignore
+            s |> Ast.Utils.createSharedVariable name storageIndex globalLevel |> ignore
 
     // Then build all child scopes variables
     for child in !d.Children do
@@ -84,15 +83,15 @@ module Analyzer =
     let globalLevel, closureLevel = 
 
       match d.Scope with
-      | Catch s ->
+      | Ast.ScopeOption.Catch s ->
         // Catch scope is simple, always increase closure level
         s := {!s with ClosureLevel = closureLevel + 1}
         (!s).GlobalLevel, (!s).ClosureLevel
 
-      | Function s ->
+      | Ast.ScopeOption.Function s ->
 
         let globalLevel = 
-          s |> NewVars.globalLevel
+          s |> Ast.Utils.globalLevel
 
         // Calculate the new closure level
         // which is either the same as previous
@@ -108,10 +107,10 @@ module Analyzer =
         // shared variables in the current scope
         let updateClosureLevels _ var =
           match var with
-          | Shared(s, g, _) ->
+          | Ast.Variable.Shared(s, g, _) ->
             if g = globalLevel
-              then Shared(s, g, closureLevel)
-              else Shared(s, g, levels.[g])
+              then Ast.Variable.Shared(s, g, closureLevel)
+              else Ast.Variable.Shared(s, g, levels.[g])
 
           | _ -> var
 

Src/IronJS/Compiler.Ast.fs

@@ -5,6 +5,7 @@ open IronJS.Support.Aliases
 open System.Globalization
 
 ///
+[<RequireQualifiedAccess>]
 module Ast =  
 
   ///
@@ -82,7 +83,7 @@ module Ast =
     | Eval of Tree
     | New of Tree * Tree list
     | Return of Tree
-    | FunctionFast of string option * FunctionScope ref * Tree
+    | Function of string option * FunctionScope ref * Tree
     | Invoke of Tree * Tree list
     | Label of string * Tree
     | For of string option * Tree * Tree * Tree * Tree
@@ -111,29 +112,29 @@ module Ast =
 
   /// The two different types of scopes possible
   and ScopeType
-    = GlobalScope = 0
-    | FunctionScope = 1
+    = GlobalScope
+    | FunctionScope 
 
   /// The ways in a function can be effected by eval
   /// 
   /// Clean = No eval call that can effect this function detected
   /// Contains = An eval call exists inside this function
   /// Effected = An eval call exists in one of the scopes containing this function
   and EvalMode
-    = Clean = 0
-    | Contains = 1
-    | Effected = 2
+    = Clean 
+    | Contains 
+    | Effected 
 
   /// The two different types of lookup modes that a 
   /// function can use, dynamic is used if a function 
   /// contains either an eval call or a with statement
   /// otherwise static is used (which is a lot faster)
   and LookupMode
-    = Static = 0
-    | Dynamic = 1
+    = Static 
+    | Dynamic 
 
   /// Represents a function scope
-  and Scope = {
+  and FunctionScope = {
     Id : uint64
 
     GlobalLevel: int
@@ -154,10 +155,37 @@ module Ast =
     CatchScopes : CatchScope ref list
     ParameterNames : string list
     Globals : string Set
+  }
 
-  } with
-    static member NewGlobal = {Scope.New with ScopeType = ScopeType.GlobalScope}
-    static member New = {
+  /// Represents a catch scope
+  and CatchScope = {
+    Name : string
+    GlobalLevel : int
+    ClosureLevel : int
+    CatchScopes : CatchScope ref list
+  }
+
+  ///
+  and ScopeOption
+    = Catch of CatchScope ref
+    | Function of FunctionScope ref
+
+  ///
+  and [<NoComparison; NoEquality>] Variable
+    = Shared  of int * int * int
+    | Private of int
+
+  and VariableMap = Map<string, Variable>
+
+  ///
+  [<RequireQualifiedAccess>]
+  module Utils =
+    
+    // Type short hand for scopes
+    type private S = FunctionScope ref
+
+    ///
+    let createFunctionScope() = {
       Id = 0UL
 
       GlobalLevel = 0
@@ -180,37 +208,18 @@ module Ast =
       Globals = Set.empty
     }
 
-  /// Represents a catch scope
-  and CatchScope = {
-    Name : string
-    GlobalLevel : int
-    ClosureLevel : int
-    CatchScopes : CatchScope ref list
-  } with 
-    static member New name globalLevel closureLevel = ref {
+    ///
+    let createGlobalScope() =
+      {createFunctionScope()with ScopeType = ScopeType.GlobalScope}
+      
+    ///
+    let createCatchScope name globalLevel closureLevel = ref {
       Name = name
       GlobalLevel = globalLevel
       ClosureLevel = closureLevel
       CatchScopes = List.empty
     }
 
-  and FunctionScope = Scope
-
-  and ScopeOption
-    = Catch of CatchScope ref
-    | Function of FunctionScope ref
-
-  and [<NoComparison; NoEquality>] Variable
-    = Shared  of int * int * int
-    | Private of int
-
-  and VariableMap = Map<string, Variable>
-
-  module NewVars =
-    
-    // Type short hand for scopes
-    type private S = FunctionScope ref
-
     ///
     let clone s = ref !s
 
@@ -310,7 +319,7 @@ module Ast =
     ///
     let addFunction (ast:Tree) (s:S) =
       match ast with
-      | FunctionFast(Some name, _, _) ->
+      | Tree.Function(Some name, _, _) ->
         s := {!s with Functions = (!s).Functions |> Map.add name ast}
 
       | _ -> 

Src/IronJS/Compiler.Context.fs

@@ -66,7 +66,7 @@ module Target =
     env |> create ast Mode.Global None
 
 ///
-module Labels = 
+module internal Labels = 
 
   type LabelGroup =
     Map<string, int * Dlr.Label> * Map<int, Dlr.Label> ref
@@ -113,7 +113,7 @@ module Labels =
       }
 
 ///
-module Parameters =
+module internal Parameters =
 
   ///
   type T = {
@@ -147,7 +147,7 @@ module Parameters =
     (t |> environment) .-> "Return"
 
 ///
-module Context = 
+module internal Context = 
 
   type T = {
     CompileFunction : Target.T -> Delegate
@@ -167,7 +167,7 @@ module Context =
     member x.Env = x.Parameters |> Parameters.environment
     member x.Globals = x.Parameters |> Parameters.globals
     member x.ReturnBox = x.Parameters |> Parameters.returnBox
-    member x.DynamicLookup = x.Scope |> Ast.NewVars.hasDynamicLookup || x.InsideWith
+    member x.DynamicLookup = x.Scope |> Ast.Utils.hasDynamicLookup || x.InsideWith
     member x.Compile ast = x.Compiler x ast
 
   ///
@@ -192,7 +192,8 @@ module Context =
 type Ctx = Context.T
 
 ///
-type [<AllowNullLiteral>] EvalTarget() = 
+[<AllowNullLiteral>] 
+type EvalTarget() = 
   [<DefaultValue>] val mutable Target : BV
   [<DefaultValue>] val mutable GlobalLevel : int
   [<DefaultValue>] val mutable ClosureLevel : int

Src/IronJS/Compiler.ControlFlow.fs

@@ -8,7 +8,7 @@ open IronJS.Dlr.Operators
 open IronJS.Compiler
 open IronJS.Compiler.Context
 
-module ControlFlow =
+module internal ControlFlow =
 
   //----------------------------------------------------------------------------
   // 11.12 conditional

Src/IronJS/Compiler.Core.fs

@@ -50,7 +50,6 @@ module Core =
     | Ast.BreakPoint(line, column) ->
 
       #if ENABLE_BREAKPOINTS
-
       let locals = 
         Dlr.blockTmpT<MutableDict<string, obj>> (fun locals ->
           let addLocal (name, _) =
@@ -66,7 +65,6 @@ module Core =
 
       let args = [!!!line; !!!column; locals]
       Dlr.invoke (ctx.Env .-> "BreakPoint") args
-
       #else
       Dlr.void'
       #endif
@@ -110,7 +108,7 @@ module Core =
     | Ast.Invoke(func, args)  -> Function.invoke ctx func args
     | Ast.New(func, args) -> Function.new' ctx func args
     | Ast.Return tree -> Function.return' ctx tree
-    | Ast.FunctionFast(_, scope, _) -> Function.create ctx scope ast
+    | Ast.Function(_, scope, _) -> Function.create ctx scope ast
 
     //Control Flow
     | Ast.Switch(value, cases) -> ControlFlow.switch ctx value cases
@@ -142,7 +140,7 @@ module Core =
   ///
   let private cloneScope (target:Target.T) =
     match target.Ast with
-    | Ast.FunctionFast(_, s, ast) -> ref !s
+    | Ast.Function(_, s, ast) -> ref !s
 
   ///
   let rec private compile (target:Target.T) =
@@ -157,9 +155,9 @@ module Core =
       Context.T.CompileFunction = compile
       Context.T.InsideWith = false
       Context.T.Scope = scope
-      Context.T.ClosureLevel = scope $ Ast.NewVars.closureLevel
-      Context.T.Variables = scope $ Ast.NewVars.variables
-      Context.T.CatchScopes = scope $ Ast.NewVars.catchScopes $ ref
+      Context.T.ClosureLevel = scope $ Ast.Utils.closureLevel
+      Context.T.Variables = scope $ Ast.Utils.variables
+      Context.T.CatchScopes = scope $ Ast.Utils.catchScopes $ ref
 
       Context.T.Labels = 
         {