public void GlobalScope_HandleDebugOptions_Configures_Verify()
{
List <string> args = new List <string>();
args.Add("--verify");
GlobalScope.HandleDebugOptions(args);
Assert.IsTrue(Validator.IsVerifyEnabled);
}
protected override Expression VisitParameter(ParameterExpression node)
{
if (!TryLookup(node, out ParameterExpression res))
{
res = GetState(node);
GlobalScope.Add(node, res);
}
return(res);
}
private void WriteUnrefedReport(GlobalScope globalScope)
{
if (globalScope.UndefinedReferences != null && globalScope.UndefinedReferences.Count > 0)
{
// sort the undefined reference exceptions
var undefinedList = new List <UndefinedReference>(globalScope.UndefinedReferences);
undefinedList.Sort((left, right) =>
{
// first do the right thing if one or both are null
if (left == null && right == null)
{
// both null -- equal
return(0);
}
if (left == null)
{
// left is null, right is not -- left is less
return(-1);
}
if (right == null)
{
// left is not null, right is -- left is more
return(1);
}
// neither are null
int comparison = string.Compare(left.ToString(), right.ToString(), StringComparison.OrdinalIgnoreCase);
if (comparison == 0)
{
comparison = left.Line - right.Line;
if (comparison == 0)
{
comparison = left.Column - right.Column;
}
}
return(comparison);
});
// write the report
WriteProgress();
WriteProgress(NUglify.UndefinedGlobalHeader);
foreach (UndefinedReference ex in undefinedList)
{
WriteProgress(NUglify.UndefinedInfo.FormatInvariant(
ex.Name,
ex.Line,
ex.Column,
ex.ReferenceType.ToString()
));
}
}
}
public ExpressionEval(IServiceContainer services, IPythonModule module, GlobalScope gs)
{
Services = services ?? throw new ArgumentNullException(nameof(services));
Module = module ?? throw new ArgumentNullException(nameof(module));
Ast = module.GetAst();
GlobalScope = gs;
CurrentScope = GlobalScope;
DefaultLocation = new Location(module);
//Log = services.GetService<ILogger>();
}
private void CloseSession()
{
if (GlobalScope != null)
{
GlobalScope.QuickClose();
GlobalScope.Dispose();
GlobalScope = null;
Logger.Current.Info(() => LedgerSessionEnded);
}
}
private InsertMethodsPass CreatePass(params Function[] functions)
{
var scope = GlobalScope.Generate();
foreach (var fn in functions)
{
scope.DeclareFunction(fn);
}
return(new InsertMethodsPass(scope.GlobalScope));
}
public void GlobalScope_HandleDebugOptions_Configures_Trace()
{
List <string> args = new List <string>();
args.Add("--trace");
args.Add("23");
GlobalScope.HandleDebugOptions(args);
Assert.Equal(LogLevelEnum.LOG_TRACE, Logger.Current.LogLevel);
Assert.Equal(23, Logger.Current.TraceLevel);
}
public ExpressionEval(IServiceContainer services, IPythonModule module, PythonAst ast)
{
Services = services ?? throw new ArgumentNullException(nameof(services));
Module = module ?? throw new ArgumentNullException(nameof(module));
Ast = ast ?? throw new ArgumentNullException(nameof(ast));
GlobalScope = new GlobalScope(module);
CurrentScope = GlobalScope;
DefaultLookupOptions = LookupOptions.Normal;
//Log = services.GetService<ILogger>();
}
public void Should_return_root_scope_by_default()
{
var globalScope = new GlobalScope <SymbolNode>();
var node = new SymbolNode("abc");
var builder = CreateScopeBuilder(globalScope);
var scope = builder.Visit(node);
scope.ShouldBeOfType <BoundScope <SymbolNode> >();
scope.TargetScope.ShouldBe(globalScope);
scope.Node.ShouldBe(node);
}
private void Dispose(bool disposing)
{
if (_scope != null)
{
_scope.engine.Close();
if (disposing)
{
GC.SuppressFinalize(this);
}
}
_scope = null;
}
public void GlobalScope_HandleDebugOptions_Configures_Debug()
{
List <string> args = new List <string>();
args.Add("--debug");
args.Add("debug-category");
GlobalScope.HandleDebugOptions(args);
Assert.Equal(LogLevelEnum.LOG_DEBUG, Logger.Current.LogLevel);
Assert.Equal("debug-category", Logger.Current.LogCategory);
}
private ReorderScopeVisitor(JSParser parser)
{
// save the mods we care about
var settings = parser.Settings;
m_moveVarStatements = settings.ReorderScopeDeclarations && settings.IsModificationAllowed(TreeModifications.CombineVarStatementsToTopOfScope);
m_moveFunctionDecls = settings.ReorderScopeDeclarations && settings.IsModificationAllowed(TreeModifications.MoveFunctionToTopOfScope);
m_combineAdjacentVars = settings.IsModificationAllowed(TreeModifications.CombineVarStatements);
//m_localRenaming = settings.LocalRenaming != LocalRenaming.KeepAll && settings.IsModificationAllowed(TreeModifications.LocalRenaming);
m_globalScope = parser.GlobalScope;
}
public PartialTrustEvaluationStrategy(string expression, VsaEngine engine)
: base(engine)
{
//
// Following is equivalent to declaring a "var" in JScript
// at the level of the Global object.
//
_scope = (GlobalScope)engine.GetGlobalScope().GetObject();
_contextField = _scope.AddField("$context");
_expression = expression;
}
/// <summary>
/// Gets the list of modules known by the current analysis.
/// </summary>
/// <param name="topLevelOnly">Only return top-level modules.</param>
public MemberResult[] GetModules(bool topLevelOnly = false)
{
List <MemberResult> res = new List <MemberResult>(ProjectState.GetModules(topLevelOnly));
var children = GlobalScope.GetChildrenPackages(InterpreterContext);
foreach (var child in children)
{
res.Add(new MemberResult(child.Key, PythonMemberType.Module));
}
return(res.ToArray());
}
public void Should_not_scope_atom_nodes()
{
var fooNode = new NumberNode("123");
var body = new ListNode(fooNode);
var methodDefinitionNode = new MethodDefinitionNode("sayMessage", new ParameterDefinitionNode[] { new ParameterDefinitionNode("message"), }, body);
var globalScope = new GlobalScope <SymbolNode>();
var builder = CreateScopeBuilder(globalScope);
var resultScope = builder.GetScope(methodDefinitionNode, globalScope);
resultScope.Descendants().OfType <BoundScope <SymbolNode> >().Any(scope => scope.Node == fooNode).ShouldBe(false);
}
static TemplateContext()
{
// Global properties
GlobalScope.SetValue("empty", NilValue.Empty);
GlobalScope.SetValue("blank", StringValue.Empty);
// Initialize Global Filters
GlobalFilters
.WithArrayFilters()
.WithStringFilters()
.WithNumberFilters()
.WithMiscFilters();
}
public void UpdateScope()
{
GlobalScope.Scope.Items.Clear();
foreach (VBlock vBlock in GlobalScopePanel.Controls)
{
AddItemToScope(vBlock);
}
GlobalScope.UpdateFunctionNames();
GlobalScope.Scope.UpdateLocalVariables();
}
public void Should_scope_parameters()
{
var body = new ListNode();
var methodDefinitionNode = new MethodDefinitionNode("sayMessage", new ParameterDefinitionNode[] { new ParameterDefinitionNode("message"), }, body);
var globalScope = new GlobalScope <SymbolNode>();
var builder = CreateScopeBuilder(globalScope);
var resultScope = builder.GetScope(methodDefinitionNode, globalScope);
resultScope.Resolve("message").ShouldNotBe(null);
resultScope.Resolve("message").ShouldBeOfType <ParameterDefinitionNode>();
}
protected static Scope Scope(params TypeMapping[] locals)
{
var globalScope = new GlobalScope();
var localScope = new LocalScope(globalScope);
foreach (var local in locals)
{
var item = local(null);
var name = local.Method.GetParameters()[0].Name;
localScope.Bind(name, item);
}
return(localScope);
}
public override void ExitFunctionCallExpression([NotNull] PigeonParser.FunctionCallExpressionContext context)
{
var functionName = context.functionCall().ID().GetText();
if (GlobalScope.TryGetFunction(functionName, out var function))
{
Types.Put(context, function.ReturnType);
}
else
{
Types.Put(context, PigeonType.Error);
errorBag.ReportUndeclaredFunction(context.GetTextSpan(), functionName);
}
}
private ActivationObject[] GetAllFunctionScopes(GlobalScope globalScope)
{
// create a list to hold all the scopes
List <ActivationObject> scopes = new List <ActivationObject>();
// recursively add all the function scopes to the list
AddScopes(scopes, globalScope);
// sort the scopes by starting line (from the context)
scopes.Sort(ScopeComparer.Instance);
// return as an array
return(scopes.ToArray());
}
public void CreateReport(TextWriter writer, GlobalScope globalScope, bool useReferenceCounts)
{
if (globalScope != null)
{
m_useReferenceCounts = useReferenceCounts;
// start the global scope
m_writer = XmlWriter.Create(writer, new XmlWriterSettings()
{
Indent = true, OmitXmlDeclaration = true
});
m_writer.WriteStartElement("global");
// recursively process each child scope
foreach (var childScope in globalScope.ChildScopes)
{
ProcessScope(childScope);
}
// process any undefined references
if (globalScope.UndefinedReferences != null && globalScope.UndefinedReferences.Count > 0)
{
m_writer.WriteStartElement("undefined");
foreach (var undefined in globalScope.UndefinedReferences)
{
m_writer.WriteStartElement("reference");
m_writer.WriteAttributeString("name", undefined.Name);
m_writer.WriteAttributeString("type", undefined.ReferenceType.ToString().ToLowerInvariant());
if (undefined.LookupNode != null && undefined.LookupNode.Context != null)
{
OutputContextPosition(undefined.LookupNode.Context);
}
else
{
m_writer.WriteAttributeString("srcLine", undefined.Line.ToStringInvariant());
m_writer.WriteAttributeString("srcCol", (undefined.Column + 1).ToStringInvariant());
}
m_writer.WriteEndElement();
}
m_writer.WriteEndElement();
}
m_writer.WriteEndElement();
m_writer.Flush();
m_writer = null;
}
}
private void CloseSession()
{
if (GlobalScope != null && MainApplicationContext != null)
{
using (MainApplicationContext.AcquireCurrentThread())
{
GlobalScope.QuickClose();
GlobalScope.Dispose();
GlobalScope = null;
Logger.Current.Info(() => LedgerSessionEnded);
}
}
}
public void Should_return_entire_bound_scope_name_as_path_to_root_scope()
{
var fakeNode = A.Fake <INode <AstNode> >();
var fakeScope = A.Fake <INamedScope <SymbolNode> >();
A.CallTo(() => fakeScope.Name).Returns("FakeScope");
var globalScope = new GlobalScope <SymbolNode>();
A.CallTo(() => fakeScope.OuterScope).Returns(globalScope);
var boundScope = new BoundScope <SymbolNode>(fakeScope, fakeNode);
boundScope.Name.ShouldBe("global/FakeScope");
}
/// <summary>
/// Resolves the given element in this scope.
/// </summary>
/// <param name="elem">The element.</param>
/// <param name="isFirst">Is the element the first one in the list.</param>
/// <returns>Resolved value or null</returns>
public object ResolveInScopes(object elem, bool isFirst)
{
object result;
// try to access the cached function value (speed optimization)
LispVariant elemAsVariant = elem as LispVariant;
if (elemAsVariant != null && elemAsVariant.CachedFunction != null)
{
return(elemAsVariant.CachedFunction);
}
var name = elem.ToString();
LispScope foundClosureScope;
// first try to resolve in this scope
if (TryGetValue(name, out result))
{
UpdateFunctionCache(elemAsVariant, result, isFirst);
}
// then try to resolve in global scope
else if (GlobalScope != null &&
GlobalScope.TryGetValue(name, out result))
{
UpdateFunctionCache(elemAsVariant, result, isFirst);
}
// then try to resolve in closure chain scope(s)
else if (IsInClosureChain(name, out foundClosureScope, out result))
{
UpdateFunctionCache(elemAsVariant, result, isFirst);
}
// then try to resolve in scope of loaded modules
else if (LispEnvironment.IsInModules(name, GlobalScope))
{
result = LispEnvironment.GetFunctionInModules(name, GlobalScope);
}
else
{
// activate this code if symbols must be resolved in parameter evaluation --> (println blub)
//if (elemAsVariant != null && elemAsVariant.IsSymbol && name != "fuellib")
//{
// throw new LispException($"Could not resolve symbol {name}");
//}
result = elem;
}
return(result);
}
public void GlobalScope_ReportError_WritesErrorIfNoCancellationReques()
{
var globalScope = new GlobalScope();
var ex = new Exception("some exception");
using (var textWriter = new StringWriter())
{
MainApplicationContext.Current.SetApplicationServiceProvider(new ApplicationServiceProvider
(virtualConsoleProviderFactory: () => new VirtualConsoleProvider(consoleError: textWriter)));
globalScope.ReportError(ex);
textWriter.Flush();
Assert.Equal("Error: some exception", textWriter.ToString().TrimEnd());
}
}
public void GlobalScope_HandleDebugOptions_Configures_ArgsOnly_VerifyMemory_InitFile()
{
List <string> args = new List <string>();
args.Add("--args-only");
args.Add("--verify-memory");
args.Add("--init-file");
args.Add("filename.ext");
GlobalScope.HandleDebugOptions(args);
Assert.True(GlobalScope.ArgsOnly);
Assert.True(Validator.IsVerifyEnabled);
Assert.Equal(LogLevelEnum.LOG_DEBUG, Logger.Current.LogLevel);
Assert.Equal("memory\\.counts", Logger.Current.LogCategory);
}
public ExpressionEval(IServiceContainer services, IPythonModule module, PythonAst ast)
{
Services = services ?? throw new ArgumentNullException(nameof(services));
Module = module ?? throw new ArgumentNullException(nameof(module));
Ast = ast ?? throw new ArgumentNullException(nameof(ast));
GlobalScope = new GlobalScope(module);
CurrentScope = GlobalScope;
DefaultLookupOptions = LookupOptions.Normal;
//Log = services.GetService<ILogger>();
_diagnostics = services.GetService <IDiagnosticsService>();
UnknownType = Interpreter.UnknownType ??
new FallbackBuiltinPythonType(new FallbackBuiltinsModule(Ast.LanguageVersion), BuiltinTypeId.Unknown);
}
public MemberResult[] GetModuleMembers(string[] names, bool includeMembers = false)
{
var res = new List <MemberResult>(ProjectState.GetModuleMembers(names, includeMembers));
var children = GlobalScope.GetChildrenPackages();
foreach (var child in children)
{
var mod = (ModuleInfo)child.Value;
var childName = mod.Name.Substring(this.GlobalScope.Name.Length + 1);
if (childName.StartsWith(names[0]))
{
res.AddRange(JsAnalyzer.GetModuleMembers(names, includeMembers, mod as IModule));
}
}
return(res.ToArray());
}
public void DoesNotTModifyVariableInUpperFromDerivedScope()
{
var sut = new GlobalScope(null, "root");
sut.SetVariable("a", new String("bottom"), false);
var derived = sut.DeriveFunctionScope();
derived.SetVariable("a", new String("derived"), true);
var innerAa = derived.GetVariable("a", new Runtime(new Processors())).Get(new Runtime(new Processors())) as String;
Assert.Equal("derived", innerAa.Value);
var a = sut.GetVariable("a", new Runtime(new Processors())).Get(new Runtime(new Processors())) as String;
Assert.Equal("bottom", a.Value);
}
public void HasATypeInWhichOnlyGenericTypeVariablesAreFreshenedOnEachScopeLookup()
{
using (TypeVariable.TestFactory())
{
//Prevent type '1' from being freshened on type lookup by marking it as non-generic:
var typeVariable0 = TypeVariable.CreateGeneric();
var typeVariable1 = TypeVariable.CreateNonGeneric();
var expectedTypeAfterLookup = new NamedType("A", new TypeVariable(4), typeVariable1, new NamedType("B", new TypeVariable(4), typeVariable1));
var definedType = new NamedType("A", typeVariable0, typeVariable1, new NamedType("B", typeVariable0, typeVariable1));
var typeChecker = new TypeChecker();
var globalScope = new GlobalScope();
var localScope = new LocalScope(globalScope);
localScope.Bind("foo", definedType);
Type("foo", localScope, typeChecker).ShouldEqual(expectedTypeAfterLookup);
}
}
/// <summary>Parses the chunk to an function.</summary>
/// <param name="runtime">Binder</param>
/// <param name="options">Compile options for the script.</param>
/// <param name="lHasEnvironment">Creates the _G parameter.</param>
/// <param name="code">Lexer for the code.</param>
/// <param name="typeDelegate">Type for the delegate. <c>null</c>, for an automatic type</param>
/// <param name="returnType">Defines the return type of the chunk.</param>
/// <param name="args">Arguments of the function.</param>
/// <returns>Expression-Tree for the code.</returns>
public static LambdaExpression ParseChunk(Lua runtime, LuaCompileOptions options, bool lHasEnvironment, LuaLexer code, Type typeDelegate, Type returnType, IEnumerable<KeyValuePair<string, Type>> args)
{
List<ParameterExpression> parameters = new List<ParameterExpression>();
if (returnType == null)
returnType = typeof(LuaResult);
var globalScope = new GlobalScope(runtime, options, returnType, returnType == typeof(LuaResult) ? Expression.Property(null, Lua.ResultEmptyPropertyInfo) : null);
// Registers the global LuaTable
if (lHasEnvironment)
parameters.Add(globalScope.RegisterParameter(typeof(LuaTable), csEnv));
if (args != null)
{
foreach (var c in args)
parameters.Add(globalScope.RegisterParameter(c.Value, c.Key)); // Add alle arguments
}
// Get the first token
if (code.Current == null)
code.Next();
// Get the name for the chunk and clean it from all unwanted chars
string sChunkName = CreateNameFromFile(code.Current.Start.FileName);
if ((globalScope.EmitDebug & LuaDebugLevel.RegisterMethods) == LuaDebugLevel.RegisterMethods)
sChunkName = Lua.RegisterUniqueName(sChunkName);
// Create the block
ParseBlock(globalScope, code);
if (code.Current.Typ != LuaToken.Eof)
throw ParseError(code.Current, Properties.Resources.rsParseEof);
// Create the function
return typeDelegate == null ?
Expression.Lambda(globalScope.ExpressionBlock, sChunkName, parameters) :
Expression.Lambda(typeDelegate, globalScope.ExpressionBlock, sChunkName, parameters);
}
public static Task<IFunctionalNamespace> ParseCompilationUnitAsync(IProjectSourceItem SourceItem, CompilationParameters Parameters, IBinder Binder, IAssembly DeclaringAssembly, MacroProcessor Processor, IMessageSink Sink)
{
Parameters.Log.LogEvent(new LogEntry("Status", "Parsing " + SourceItem.SourceIdentifier));
return Task.Run(() =>
{
var code = ProjectHandlerHelpers.GetSourceSafe(SourceItem, Parameters);
if (code == null)
{
return null;
}
var namer = ECSharpTypeNamer.Instance;
var convRules = DefaultConversionRules.Create(namer.Convert);
var globalScope = new GlobalScope(new FunctionalBinder(Binder), convRules, Parameters.Log, namer, new Flame.Syntax.MemberProvider(Binder).GetMembers, GetParameters);
bool isLes = Enumerable.Last(SourceItem.SourceIdentifier.Split('.')).Equals("les", StringComparison.OrdinalIgnoreCase);
var service = isLes ? (IParsingService)LesLanguageService.Value : EcsLanguageService.Value;
var nodes = ParseNodes(code.Source, SourceItem.SourceIdentifier, service, Processor, Sink);
if (Parameters.Log.Options.GetOption<bool>("E", false))
{
var outputService = GetParsingService(Parameters.Log.Options, "syntax-format", service);
string newFile = outputService.Print(nodes, Sink, indentString: new string(' ', 4));
Parameters.Log.LogMessage(new LogEntry("'" + SourceItem.SourceIdentifier + "' after macro expansion", Environment.NewLine + newFile));
}
var unit = ParseCompilationUnit(nodes, globalScope, DeclaringAssembly);
Parameters.Log.LogEvent(new LogEntry("Status", "Parsed " + SourceItem.SourceIdentifier));
return unit;
});
}
public static IFunctionalNamespace ParseCompilationUnit(IEnumerable<LNode> Nodes, GlobalScope Scope, IAssembly DeclaringAssembly)
{
return converter.ConvertCompilationUnit(Scope, DeclaringAssembly, Nodes);
}
protected void InitTypeSystem()
{
builtins = new BuiltInScope(this);
globals = new GlobalScope(this, builtins);
//
// Create the builtin types
//
this.builtins.Define(modelType = new ModelTypeSymbol());
this.builtins.Define(strandType = new StrandTypeSymbol());
this.builtins.Define(plexType = new PlexTypeSymbol());
this.builtins.Define(mixtureType = new MixtureTypeSymbol());
this.builtins.Define(integerType = new IntegerTypeSymbol());
this.builtins.Define(floatType = new FloatTypeSymbol());
this.builtins.Define(stringType = new StringTypeSymbol());
this.builtins.Define(voidType = new VoidTypeSymbol());
this.builtins.Define(boolType = new BoolTypeSymbol());
this.builtins.Define(objectType = new ObjectTypeSymbol());
this.builtins.Define(listOfDomainsType = new ListTypeSymbol(this));
this.builtins.Define(listOfStrandsType = new ListTypeSymbol(this));
this.builtins.Define(meltType = new CSharpClassTypeSymbol(typeof(Nadir.User.IMelt)));
this.builtins.Define(seqDesign = new CSharpClassTypeSymbol(typeof(Nadir.User.ISeqdesign)));
//
// Create the builtin properties
//
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropLengthName, integerType, fDom: true, fStr: true, inheritedByStrand: false, inheritedByComplement: false, inheritedBySubset: false, builtinSequenceProperty: true));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropPatternName, stringType, true, true, false, false, false, true));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropUndecoratedPatternName, stringType, true, true, false, false, false, true));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropDesignSeedName, stringType, true, true, false, false, false, true));
//
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropMeltName, meltType, false, true, false, false, false, false));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropDeltaGName, floatType, true, true, false, false, false, false));
//
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropDistributionName, stringType, true, false, false, false, false, false));
//
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropImportanceName, floatType, false, true, false, true, false, false));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropToeholdName, boolType, true, false, false, true, true, false));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropCountName, integerType, false, false, false, false, false, false));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropNameName, stringType, true, true, false, false, false, false));
//
this.builtins.Define(domainType = new DomainTypeSymbol(this)); // must be after string, bool, and integer, and the properties (though i can't rememer why)
//
((ListTypeSymbol)this.listOfDomainsType).SetElementType(domainType);
((ListTypeSymbol)this.listOfStrandsType).SetElementType(strandType);
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropDomainsName, listOfDomainsType, false, false, false, false, false, false));
this.builtins.Define(CreatePropertyDefinition(BuiltIns.PropStrandsName, listOfStrandsType, false, false, false, false, false, false));
//
// Create the definitions of the builtin functions
//
foreach (BuiltIns.FuncShape fn in BuiltIns.Shapes)
{
this.builtins.Define(CreateFunctionDef(fn));
}
//
// Create the 'toehold' and 'specificity' typedefs
//
this.builtins.Define(CreateTypedef(Constants.ToeholdDomainName, new DomainTypeSymbol(this, Constants.ToeholdDomainDefaultLength, true)));
this.builtins.Define(CreateTypedef(Constants.SpecificityDomainName, new DomainTypeSymbol(this, Constants.SpecificityDomainDefaultLength, false)));
//
// Create builtin variables
//
this.builtins.Define(CreateInitializedFloatVariable(BuiltIns.VarInfinityName, true, BuiltIns.VarInfinityValue));
this.builtins.Define(CreateInitializedFloatVariable(BuiltIns.VarNanName, true, BuiltIns.VarNanValue));
this.builtins.Define(CreateInitializedIntVariable (BuiltIns.VarHybridizationStabilityThresholdName, false, BuiltIns.VarHybridizationStabilityThresholdValue));
this.builtins.Define(CreateSeqdesignVariable (BuiltIns.VarSeqdesignName, true, this.Context));
//
// Create the type analysis tables
//
this.promotionTable = CreatePromotionTable();
this.arithmeticResultTable = CreateArithmeticResultTable();
this.equalityRequiredArgTypeTable = CreateEqualityRequiredArgTypeTable();
}
// Constructors
public GlobalScope(GlobalScope parent, Microsoft.JScript.Vsa.VsaEngine engine) {}
private GlobalScope CreateGlobalScope(Vector<Class> classes, Vector<Function> functions)
{
var globals = new GlobalScope();
foreach (var @class in classes)
if (!globals.TryIncludeUniqueBinding(@class.Name.Identifier, ConstructorType(@class.Name)))
LogError(CompilerError.DuplicateIdentifier(@class.Position, @class));
foreach (var function in functions)
if (!globals.TryIncludeUniqueBinding(function.Name.Identifier, typeRegistry.DeclaredType(function)))
LogError(CompilerError.DuplicateIdentifier(function.Position, function));
return globals;
}
