/// <summary> /// Populates current scope with a given <paramref name="symbolTable"/>. /// </summary> internal void PopulateFromSymbolTable([CanBeNull] ISymbolTable symbolTable) { // The binder in some cases optimizes the local table block and does not create a symbol table at all if (symbolTable == null) { return; } foreach (var kvp in symbolTable) { var symbol = kvp.Value; var declaration = symbol.DeclarationList.First(); if (declaration.Kind != TypeScript.Net.Types.SyntaxKind.VariableDeclaration && declaration.Kind != TypeScript.Net.Types.SyntaxKind.Parameter) { // Need to register only variable declarations! continue; } // TODO: next statment will fail even for valid names. // For instance, $ is not a valid character for SymbolAtom but it is a valid identifier. // This logic needs to be revisit. var atom = SymbolAtom.Create(m_stringTable, declaration.Name.Text); var location = declaration.Location(m_sourceFile, m_sourceFilePath, m_pathTable); bool isConstant = NodeUtilities.IsConst(declaration); var index = AddVariable(atom, location, isConstant); Contract.Assume( index != null, I($"Found duplicate variable '{declaration.Name.Text}' in a source file. This should never happen because binder should fail on it!")); } }
private SymbolAtom GetConfigKeyword(ISourceFile sourceFile) { string configKeywordString = sourceFile.Statements[0].TryGetFunctionNameInCallExpression(); if (configKeywordString == null) { Contract.Assert(false, I($"Configuration validation for '{Kind}' should have caught that the first statement is not a call expression")); } switch (Kind) { case ConfigurationKind.PrimaryConfig: Contract.Assert( configKeywordString == Script.Constants.Names.ConfigurationFunctionCall, I($"Configuration validation for '{Kind}' should have caught that a wrong configuration keyword was used ('{configKeywordString}' instead of '{Script.Constants.Names.ConfigurationFunctionCall}')")); return(SymbolAtom.Create(Context.StringTable, configKeywordString)); case ConfigurationKind.ModuleConfig: Contract.Assert( configKeywordString == Script.Constants.Names.ModuleConfigurationFunctionCall || configKeywordString == Script.Constants.Names.LegacyModuleConfigurationFunctionCall, I($"Configuration validation for '{Kind}' should have caught that a wrong configuration keyword was used ('{configKeywordString}' instead of either '{Script.Constants.Names.ModuleConfigurationFunctionCall}' or '{Script.Constants.Names.LegacyModuleConfigurationFunctionCall}')")); return(SymbolAtom.Create(Context.StringTable, configKeywordString)); default: throw Contract.AssertFailure(UnimplementedOperationForConfigKindErrorMessage); } }
public void Combine() { var st = new StringTable(0); PartialSymbol p1 = PartialSymbol.Create(st, "AAA"); SymbolAtom a1 = SymbolAtom.Create(st, "BBB"); PartialSymbol p2 = p1.Combine(a1); XAssert.AreEqual(@"AAA.BBB", p2.ToString(st)); p1 = PartialSymbol.Create(st, string.Empty); p2 = p1.Combine(a1); XAssert.AreEqual(@"BBB", p2.ToString(st)); p1 = PartialSymbol.Create(st, "AAA"); SymbolAtom a2 = SymbolAtom.Create(st, "CCC"); p2 = p1.Combine(a1, a2); XAssert.AreEqual(@"AAA.BBB.CCC", p2.ToString(st)); p1 = PartialSymbol.Create(st, "AAA"); a2 = SymbolAtom.Create(st, "CCC"); SymbolAtom a3 = SymbolAtom.Create(st, "DDD"); p2 = p1.Combine(a1, a2, a3); XAssert.AreEqual(@"AAA.BBB.CCC.DDD", p2.ToString(st)); PartialSymbol p3 = p1.Combine(p2); XAssert.AreEqual(@"AAA.AAA.BBB.CCC.DDD", p3.ToString(st)); }
/// <nodoc /> private Binder(RuntimeModelContext runtimeModelContext) { Contract.Requires(runtimeModelContext != null); m_runtimeModelContext = runtimeModelContext; m_runtimeRootNamespaceSymbol = SymbolAtom.Create(runtimeModelContext.StringTable, Constants.Names.RuntimeRootNamespaceAlias); }
private EvaluationResult DoGetOrAdd(Context context, ModuleLiteral env, EvaluationResult key, EvaluationResult?state, Closure factoryClosure) { var helper = new HashingHelper(context.PathTable, recordFingerprintString: false); // Add the qualifier to the key var qualifierId = context.LastActiveModuleQualifier.QualifierId; var qualifierDisplayString = context.ContextTree.FrontEndContext.QualifierTable.GetQualifier(qualifierId).ToDisplayString(StringTable); helper.Add(qualifierDisplayString); if (!TryHashValue(key, helper)) { return(EvaluationResult.Error); } var keyFingerprint = helper.GenerateHash().ToHex(); var thunkCreatedByThisThread = false; // ensure that all concurrent evaluations of the same value cache key will get the same thunk and module var thunkAndModule = context.EvaluationScheduler.ValueCacheGetOrAdd( keyFingerprint, () => { var factoryArgs = state.HasValue ? new Expression[] { new LocalReferenceExpression(SymbolAtom.Create(context.StringTable, "state"), index: factoryClosure.Frame.Length, default) } : CollectionUtilities.EmptyArray <Expression>(); var thunk = new Thunk(ApplyExpression.Create(factoryClosure, factoryArgs, factoryClosure.Location), null); var module = context.LastActiveUsedModule; thunkCreatedByThisThread = true; return(thunk, module); });
public void TryCreate() { var st = new StringTable(0); PartialSymbol p; XAssert.IsTrue(PartialSymbol.TryCreate(st, @"AAA.CCC", out p)); XAssert.AreEqual(@"AAA.CCC", p.ToString(st)); XAssert.IsFalse(PartialSymbol.TryCreate(st, @"C.:AAA", out p)); XAssert.IsFalse(PartialSymbol.TryCreate(st, @"AAA:", out p)); XAssert.IsFalse(PartialSymbol.TryCreate(st, @":AAA", out p)); XAssert.IsFalse(PartialSymbol.TryCreate(st, @"..", out p)); XAssert.IsFalse(PartialSymbol.TryCreate(st, @".", out p)); XAssert.IsFalse(PartialSymbol.TryCreate(st, @"B.", out p)); XAssert.IsFalse(PartialSymbol.TryCreate(st, @"B..", out p)); p = PartialSymbol.Create(st, string.Empty); XAssert.AreEqual(string.Empty, p.ToString(st)); p = PartialSymbol.Create(st, "BBB"); XAssert.AreEqual("BBB", p.ToString(st)); SymbolAtom a1 = SymbolAtom.Create(st, "AAA"); SymbolAtom a2 = SymbolAtom.Create(st, "BBB"); SymbolAtom a3 = SymbolAtom.Create(st, "CCC"); p = PartialSymbol.Create(a1, a2, a3); XAssert.AreEqual(@"AAA.BBB.CCC", p.ToString(st)); }
private SelectorExpression CreateStringInterpolateSelectorExpression() { return(new SelectorExpression( new ModuleIdExpression(FullSymbol.Create(RuntimeModelContext.SymbolTable, Names.StringNamespace), location: default(LineInfo)), SymbolAtom.Create(RuntimeModelContext.StringTable, Names.InterpolateString), location: default(LineInfo))); }
/// <nodoc /> protected internal AmbientDefinitionBase(string ambientName, PrimitiveTypes knownTypes) { Contract.Requires(knownTypes != null); AmbientTypes = knownTypes; AmbientName = ambientName == null ? SymbolAtom.Invalid : SymbolAtom.Create(knownTypes.StringTable, ambientName); }
public void Conversion() { var st = new StringTable(0); SymbolAtom a1 = SymbolAtom.Create(st, "AAA"); PartialSymbol p1 = PartialSymbol.Create(a1); XAssert.AreEqual("AAA", p1.ToString(st)); }
public void Concat() { var idt = new SymbolTable(); FullSymbol a1 = FullSymbol.Create(idt, @"C.A"); SymbolAtom p1 = SymbolAtom.Create(idt.StringTable, "B"); FullSymbol a2 = a1.Concat(idt, p1); XAssert.AreEqual(@"C.AB", a2.ToString(idt)); }
public void Concat() { var st = new StringTable(0); PartialSymbol rp = PartialSymbol.Create(st, @"AAA.BBB"); SymbolAtom p1 = SymbolAtom.Create(st, "XXX"); PartialSymbol rp2 = rp.Concat(st, p1); XAssert.AreEqual(@"AAA.BBBXXX", rp2.ToString(st)); }
/// <nodoc /> public AmbientContext(PrimitiveTypes knownTypes) : base(ContextName, knownTypes) { var currentHost = Host.Current; var osName = SymbolAtom.Create(StringTable, "os"); string osValue; switch (currentHost.CurrentOS) { case BuildXL.Interop.OperatingSystem.Win: osValue = "win"; break; case BuildXL.Interop.OperatingSystem.MacOS: osValue = "macOS"; break; case BuildXL.Interop.OperatingSystem.Unix: osValue = "unix"; break; default: throw Contract.AssertFailure("Unhandled HostOS Type"); } var cpuName = SymbolAtom.Create(StringTable, "cpuArchitecture"); string cpuValue; switch (currentHost.CpuArchitecture) { case HostCpuArchitecture.X86: cpuValue = "x86"; break; case HostCpuArchitecture.X64: cpuValue = "x64"; break; default: throw Contract.AssertFailure("Unhandled CpuArchitecture Type"); } var isElevatedName = SymbolAtom.Create(StringTable, "isElevated"); var isElevatedValue = CurrentProcess.IsElevated; m_currentHost = ObjectLiteral.Create( new Binding(osName, osValue, default(LineInfo)), new Binding(cpuName, cpuValue, default(LineInfo)), new Binding(isElevatedName, isElevatedValue, default(LineInfo)) ); MountNameObject = Symbol("name"); MountPathObject = Symbol("path"); }
public XmlContext(StringTable stringTable) { StringTable = stringTable; KindField = SymbolAtom.Create(stringTable, "kind"); NameField = SymbolAtom.Create(stringTable, "name"); PrefixField = SymbolAtom.Create(stringTable, "prefix"); LocalField = SymbolAtom.Create(stringTable, "local"); NamespaceField = SymbolAtom.Create(stringTable, "namespace"); NodesField = SymbolAtom.Create(stringTable, "nodes"); AttributesField = SymbolAtom.Create(stringTable, "attributes"); ValueField = SymbolAtom.Create(stringTable, "value"); TextField = SymbolAtom.Create(stringTable, "text"); }
/// <inheritdoc /> protected override bool IsQualifierDeclaration(IStatement statement) { return(statement.IsQualifierDeclaration(GetQualifierNameAsAtom(), Names.CurrentQualifier)); SymbolAtom GetQualifierNameAsAtom() { if (!m_qualifierNameAsAtom.IsValid) { m_qualifierNameAsAtom = SymbolAtom.Create(m_pathTable.StringTable, Names.CurrentQualifier); } return(m_qualifierNameAsAtom); } }
/// <summary> /// Tries to find the object literal associated to the configuration. /// Since we actually support two config keywords (the legacy one is there for compat reasons), we need to check both cases /// Returns null if the result cannot be casted to an object literal. /// </summary> private ObjectLiteral ResolveConfigObjectLiteral(ModuleLiteral instantiatedModule, Context context) { var bindings = instantiatedModule.GetAllBindings(context).ToList(); Contract.Assert(bindings.Count == 1, "Expected AstConverter to produce exactly one binding in the resulting ModuleLiteral when converting a config file"); var binding = bindings.Single(); return(instantiatedModule .GetOrEvalFieldBinding( context, SymbolAtom.Create(context.StringTable, Script.Constants.Names.ConfigurationFunctionCall), binding.Value, instantiatedModule.Location) .Value as ObjectLiteral); }
private static EvaluationResult MapWithState(Context context, ArrayLiteral receiver, EvaluationResult arg0, EvaluationResult arg1, EvaluationStackFrame captures) { var closure = Converter.ExpectClosure(arg0); int paramsCount = closure.Function.Params; var state = arg1; var arrays = new EvaluationResult[receiver.Length]; using (var frame = EvaluationStackFrame.Create(closure.Function, captures.Frame)) { var entry = context.TopStack; var stateName = SymbolAtom.Create(context.FrontEndContext.StringTable, "state"); var elemsName = SymbolAtom.Create(context.FrontEndContext.StringTable, "elems"); var elemName = SymbolAtom.Create(context.FrontEndContext.StringTable, "elem"); for (int i = 0; i < receiver.Length; ++i) { frame.TrySetArguments(paramsCount, state, receiver[i], i, EvaluationResult.Create(receiver)); EvaluationResult mapResult = context.InvokeClosure(closure, frame); if (mapResult.IsErrorValue) { return(EvaluationResult.Error); } if (!(mapResult.Value is ObjectLiteral objectResult)) { throw Converter.CreateException <ObjectLiteral>(mapResult, default(ConversionContext)); } arrays[i] = objectResult[elemName]; state = objectResult[stateName]; } var bindings = new List <Binding> { new Binding(elemsName, ArrayLiteral.CreateWithoutCopy(arrays, entry.InvocationLocation, entry.Path), location: default(LineInfo)), new Binding(stateName, state, location: default(LineInfo)), }; return(EvaluationResult.Create(ObjectLiteral.Create(bindings, entry.InvocationLocation, entry.Path))); } }
/// <nodoc /> public AmbientContext(PrimitiveTypes knownTypes) : base(ContextName, knownTypes) { var currentHost = Host.Current; var osName = SymbolAtom.Create(StringTable, "os"); string osValue = currentHost.CurrentOS.GetDScriptValue(); if (string.IsNullOrEmpty(osValue)) { throw Contract.AssertFailure("Unhandled HostOS Type"); } var cpuName = SymbolAtom.Create(StringTable, "cpuArchitecture"); string cpuValue; switch (currentHost.CpuArchitecture) { case HostCpuArchitecture.X86: cpuValue = "x86"; break; case HostCpuArchitecture.X64: cpuValue = "x64"; break; default: throw Contract.AssertFailure("Unhandled CpuArchitecture Type"); } var isElevatedName = SymbolAtom.Create(StringTable, "isElevated"); var isElevatedValue = CurrentProcess.IsElevated; m_currentHost = ObjectLiteral.Create( new Binding(osName, osValue, default(LineInfo)), new Binding(cpuName, cpuValue, default(LineInfo)), new Binding(isElevatedName, isElevatedValue, default(LineInfo)) ); MountNameObject = Symbol("name"); MountPathObject = Symbol("path"); }
/// <summary> /// Creates a simulation of a local scope such that passed local variable indexes match /// </summary> private static FunctionScope BuildLocalScopeForLocalVars(Context context, StackEntry stackEntry) { var stringTable = context.StringTable; var localScope = new FunctionScope(); var localVariables = DebugInfo.ComputeCurrentLocals(stackEntry); if (localVariables.Count == 0) { return(localScope); } // Sort variables by index var localsByIndex = new SortedDictionary <int, ILocalVar>(); foreach (var localVar in localVariables) { localsByIndex[localVar.Index] = localVar; } // Construct a local scope where variable indexes are respected, filling with dummy variables if there are holes in the index range int currentIndex = 0; foreach (int index in localsByIndex.Keys) { Contract.Assert(currentIndex <= index); while (index != currentIndex) { var dummyIndex = localScope.AddVariable(SymbolAtom.Create(stringTable, "__dummy_var__" + currentIndex), default(UniversalLocation), isConstant: false); Contract.Assert(dummyIndex != null); currentIndex++; } var indexResult = localScope.AddVariable(localsByIndex[index].Name, default(UniversalLocation), isConstant: false); Contract.Assert(indexResult == index); currentIndex++; } return(localScope); }
public void TestFunctionDeclaration() { var symbolAtom = SymbolAtom.Create(m_stringTable, "y"); FunctionDeclaration node = new FunctionDeclaration( new List <SymbolAtom> { GetSymbolAtom(), symbolAtom }, GetSymbolAtom(), GetCallSignature(), GetStatement1(), captures: 0, locals: 0, modifier: Declaration.DeclarationFlags.Export, location: DefaultLineInfo, stringTable: StringTable); var deserialized = CheckSerializationRoundTrip(node); Assert.NotNull(deserialized.Statistic); }
public void Combine() { var idt = new SymbolTable(); FullSymbol a1 = FullSymbol.Create(idt, @"C"); SymbolAtom p1 = SymbolAtom.Create(idt.StringTable, "A"); FullSymbol a2 = a1.Combine(idt, p1); XAssert.AreEqual(@"C.A", a2.ToString(idt)); a1 = FullSymbol.Create(idt, @"C.X"); p1 = SymbolAtom.Create(idt.StringTable, "A"); a2 = a1.Combine(idt, p1); XAssert.AreEqual(@"C.X.A", a2.ToString(idt)); a1 = FullSymbol.Create(idt, @"C.X"); p1 = SymbolAtom.Create(idt.StringTable, "A"); SymbolAtom p2 = SymbolAtom.Create(idt.StringTable, "B"); a2 = a1.Combine(idt, p1, p2); XAssert.AreEqual(@"C.X.A.B", a2.ToString(idt)); a1 = FullSymbol.Create(idt, @"C.X"); p1 = SymbolAtom.Create(idt.StringTable, "A"); p2 = SymbolAtom.Create(idt.StringTable, "B"); SymbolAtom p3 = SymbolAtom.Create(idt.StringTable, "C"); a2 = a1.Combine(idt, p1, p2, p3); XAssert.AreEqual(@"C.X.A.B.C", a2.ToString(idt)); a1 = FullSymbol.Create(idt, @"C"); PartialSymbol rp = PartialSymbol.Create(idt.StringTable, @"A.B"); a2 = a1.Combine(idt, rp); XAssert.AreEqual(@"C.A.B", a2.ToString(idt)); a1 = FullSymbol.Create(idt, @"C.X"); rp = PartialSymbol.Create(idt.StringTable, @"A.B"); a2 = a1.Combine(idt, rp); XAssert.AreEqual(@"C.X.A.B", a2.ToString(idt)); }
/// <inheritdoc/> protected override EvaluationResult DoEval(Context context, ModuleLiteral env, EvaluationStackFrame frame) { var result = m_expression.Eval(context, env, frame); if (result.IsErrorValue) { return(result); } if (!(result.Value is ModuleLiteral module)) { var thisNodeType = nameof(ModuleToObjectLiteral); throw Contract.AssertFailure( $"AstConverter should never create a '{thisNodeType}' node that wraps an expression that evaluates to something other than {nameof(ModuleLiteral)}. " + $"Instead, this '{thisNodeType}' wraps an expression of type '{m_expression.GetType().Name}' which evaluated to an instance of type '{result.Value?.GetType().Name}'."); } var bindings = module .GetAllBindings(context) .Where(kvp => kvp.Key != Constants.Names.RuntimeRootNamespaceAlias) .Select(kvp => { var name = SymbolAtom.Create(context.StringTable, kvp.Key); var location = kvp.Value.Location; var evalResult = module.GetOrEvalFieldBinding(context, name, kvp.Value, location); return(new Binding(name, evalResult.Value, location)); }) .ToArray(); if (bindings.Any(b => b.Body.IsErrorValue())) { return(EvaluationResult.Error); } var objectLiteral = ObjectLiteral.Create(bindings); return(EvaluationResult.Create(objectLiteral)); }
/// <nodoc /> public Literals(StringTable stringTable) { Contract.Requires(stringTable != null); m_stringTable = stringTable; Obsolete = SymbolAtom.Create(stringTable, ObsoleteString); ForeignFunction = SymbolAtom.Create(stringTable, ForeignFunctionString); PathNamespace = SymbolAtom.Create(stringTable, "Path"); RelativePathNamespace = SymbolAtom.Create(stringTable, "RelativePath"); PathAtomNamespace = SymbolAtom.Create(stringTable, "PathAtom"); PathCombine = SymbolAtom.Create(stringTable, "combine"); PathCombinePaths = SymbolAtom.Create(stringTable, "combinePaths"); PathInterpolate = SymbolAtom.Create(stringTable, Literals.InterpolateString); ArrayConcat = SymbolAtom.Create(stringTable, "concat"); FileNamespace = SymbolAtom.Create(stringTable, "File"); DirectoryNamespace = SymbolAtom.Create(stringTable, "Directory"); FileDirCreate = SymbolAtom.Create(stringTable, "fromPath"); InlineImportFrom = SymbolAtom.Create(stringTable, Names.InlineImportFunction); DotDscExtension = PathAtom.Create(stringTable, Names.DotDscExtension); ConfigDsc = PathAtom.Create(stringTable, Names.ConfigDsc); ConfigBc = PathAtom.Create(stringTable, Names.ConfigBc); PackageDsc = PathAtom.Create(stringTable, Names.PackageDsc); this.DotConfigDotDscExtension = PathAtom.Create(stringTable, Names.DotConfigDotDscExtension); PackageConfigDsc = PathAtom.Create(stringTable, Names.PackageConfigDsc); ModuleConfigBm = PathAtom.Create(stringTable, Names.ModuleConfigBm); ModuleConfigDsc = PathAtom.Create(stringTable, Names.ModuleConfigDsc); ConfigurationKeyword = SymbolAtom.Create(stringTable, Names.ConfigurationFunctionCall); LegacyPackageKeyword = SymbolAtom.Create(stringTable, Names.LegacyModuleConfigurationFunctionCall); ModuleKeyword = SymbolAtom.Create(stringTable, Names.ModuleConfigurationFunctionCall); QualifierDeclarationKeyword = SymbolAtom.Create(stringTable, Names.CurrentQualifier); WithQualifierKeyword = SymbolAtom.Create(stringTable, Names.WithQualifierFunction); RuntimeRootNamespaceSymbol = SymbolAtom.Create(stringTable, Names.RuntimeRootNamespaceAlias); TemplateReference = SymbolAtom.Create(stringTable, Names.TemplateReference); UndefinedLiteral = SymbolAtom.Create(stringTable, "undefined"); CustomMergeFunction = SymbolAtom.Create(stringTable, Names.CustomMergeFunctionName); }
/// <nodoc /> public AmbientObject(PrimitiveTypes knownTypes) : base("Object", knownTypes) { m_customMergeFunction = SymbolAtom.Create(knownTypes.StringTable, Constants.Names.CustomMergeFunctionName); }
private SymbolAtom CreateSymbol(string name) => SymbolAtom.Create(RuntimeModelContext.StringTable, name);
/// <summary> /// Creates name. /// </summary> public SymbolAtom Create(string name) { Contract.Requires(!string.IsNullOrWhiteSpace(name)); return(SymbolAtom.Create(m_stringTable, name)); }
/// <summary> /// Gets named type reference from a string. /// </summary> /// <remarks>This method should only be used temporarily to handle unexpected types.</remarks> public Type CreateNamedTypeReference(string name) { Contract.Requires(!string.IsNullOrWhiteSpace(name)); return(new NamedTypeReference(SymbolAtom.Create(StringTable, name))); }
private SymbolAtom CreateSymbol(string name) { return(SymbolAtom.Create(RuntimeModelContext.StringTable, name)); }
public SymbolAtom GetSymbolAtom() => SymbolAtom.Create(m_stringTable, "x");
/// <nodoc /> protected SymbolAtom Symbol(string name) { return(SymbolAtom.Create(StringTable, name)); }