Example #1
0
 private ObjectInfo PipFragmentInfo(EvaluationContext context, PipFragment pipFrag)
 {
     return(pipFrag.FragmentType == PipFragmentType.StringLiteral ? GetObjectInfo(context, pipFrag.GetStringIdValue()) :
            pipFrag.FragmentType == PipFragmentType.AbsolutePath ? GetObjectInfo(context, pipFrag.GetPathValue()) :
            pipFrag.FragmentType == PipFragmentType.NestedFragment ? GetObjectInfo(context, pipFrag.GetNestedFragmentValue()) :
            new ObjectInfo("{invalid}"));
 }
Example #2
0
        /// <summary>
        ///     Returns a "VSCode Protocol" variable representing a given object.  For the name of the returned
        ///     variable, the <paramref name="variableName"/> argument is used verbatim; the value of the returned
        ///     variable is the preview of the <paramref name="value"/> argument, exactly the same as it would be
        ///     rendered in the "variables" pane in VSCode; finally, the a handle is created and the
        ///     <see cref="IVariable.VariablesReference"/> field is set to non-zero if the object is compound
        ///     (i.e., can be drilled down into).
        /// </summary>
        internal IVariable ObjectToVariable(EvaluationContext context, object value, string variableName)
        {
            // fetch info for the property to see if it's compound or not
            var propObjInfo = GetObjectInfo(context, value);
            var varRef      = propObjInfo.Properties.Any()
                ? m_handles.Create(new ObjectContext(context, value))
                : 0; // the VSCode debug protocol specifies 0 to mean "non-compound object" (one that has no properties)

            return(new Variable(variableName, propObjInfo.Preview, varRef));
        }
Example #3
0
        private static List <Property> GetPackageProperties(EvaluationContext context, Package package)
        {
            Contract.Requires(context != null);
            Contract.Requires(package != null);

            return(new List <Property>
            {
                new Property(":name", package.Id.Name.ToString(context.StringTable)),
                new Property(":version", package.Id.Version.ToString(context.StringTable)),
            });
        }
Example #4
0
        private static ObjectInfo ModuleLiteralInfo(EvaluationContext context, ModuleLiteral modLit)
        {
            Contract.Requires(context != null);
            Contract.Requires(modLit != null);

            string preview = GetModuleKind(modLit);

            var properties = new List <Property>();

            PopulatePredefinedModuleLiteralProperties(modLit, properties, context);

            properties.AddRange(DictToProps(modLit.GetAllBindings(context)));

            return(new ObjectInfo(preview, properties));
        }
Example #5
0
        private static ObjectLiteral GetQualifierSpaceValue(EvaluationContext context, QualifierSpaceId qualifierSpaceId)
        {
            Contract.Requires(context != null);
            Contract.Requires(context.FrontEndContext.QualifierTable.IsValidQualifierSpaceId(qualifierSpaceId));

            var qualifierSpace = context.FrontEndContext.QualifierTable.GetQualifierSpace(qualifierSpaceId);
            var bindings       = new List <Binding>(qualifierSpace.Keys.Count);

            foreach (var kvp in qualifierSpace.AsDictionary)
            {
                var values = ArrayLiteral.CreateWithoutCopy(kvp.Value.Select(s => EvaluationResult.Create(s.ToString(context.StringTable))).ToArray(), default(LineInfo), AbsolutePath.Invalid);
                bindings.Add(new Binding(kvp.Key, values, default(LineInfo)));
            }

            return(ObjectLiteral.Create(bindings, default(LineInfo), AbsolutePath.Invalid));
        }
Example #6
0
        private ObjectInfo CallableValueInfo(EvaluationContext context, CallableValue cv)
        {
            if (cv.IsProperty)
            {
                return(GetObjectInfo(context, cv.Apply(context, EvaluationStackFrame.Empty())));
            }

            var           captures = EvaluationStackFrame.Empty();
            var           @null    = UndefinedValue.Instance;
            Func <object> func     = CreateFunc();

            return(func != null
                ? FuncObjInfo(func, RenderCallableSignature(cv.CallableMember))
                : new ObjectInfo("function(" + RenderCallableSignature(cv.CallableMember) + ")"));

            // Local functions
            Func <object> CreateFunc()
            {
                var undefined = EvaluationResult.Undefined;

                switch (cv.CallableMember.Kind)
                {
                case SyntaxKind.Function0:
                    return(() => cv.Apply(context, captures).Value);

                case SyntaxKind.Function1 when cv.CallableMember.MinArity == 0:
                    return(() => cv.Apply(context, undefined, captures).Value);

                case SyntaxKind.Function2 when cv.CallableMember.MinArity == 0:
                    return(() => cv.Apply(context, undefined, undefined, captures).Value);

                case SyntaxKind.FunctionN when cv.CallableMember.MinArity == 0:
                    return(() => cv.Apply(context, BuildXL.Utilities.Collections.CollectionUtilities.EmptyArray <EvaluationResult>(), captures).Value);
                }

                return(null);
            }
        }
Example #7
0
        internal IEnumerable <Property> GetAmbientProperties(EvaluationContext context, object obj)
        {
            if (obj == null)
            {
                return(Property.Empty);
            }

            AmbientDefinitionBase ambientDefinition;

            if (!((ModuleRegistry)context.FrontEndHost.ModuleRegistry).PredefinedTypes.AllAmbientDefinitions.TryGetValue(obj.GetType(), out ambientDefinition))
            {
                return(Property.Empty);
            }

            return(ambientDefinition.GetCallableMembers(context.StringTable)

                   // sort by: properties first, functions next; in both groups, sort by name
                   .OrderBy(kvp => Invariant("{0}_{1}", kvp.Value.IsProperty ? 1 : 2, kvp.Key))
                   .Select(kvp => new Property(
                               name: kvp.Key,
                               value: TryBind(kvp.Value, obj) ?? "<error: couldn't bind callable member to receiver>",
                               kind: kvp.Value.IsProperty ? CompletionItemType.property : CompletionItemType.method)));
        }
Example #8
0
 private static ObjectInfo PrimitiveObjInfo(EvaluationContext context, object obj)
 {
     return(new ObjectInfo(ToStringConverter.ObjectToString(context, obj)));
 }
Example #9
0
 private static ObjectInfo PackageInfo(EvaluationContext context, Package package)
 {
     return(new ObjectInfo("package", GetPackageProperties(context, package)));
 }
Example #10
0
 private static ObjectInfo ErrorValueInfo(EvaluationContext context)
 {
     Contract.Requires(context != null);
     return(new ObjectInfo("<error>"));
 }
Example #11
0
        private static void PopulatePredefinedModuleLiteralProperties(ModuleLiteral env, List <Property> properties, EvaluationContext context)
        {
            Contract.Requires(env != null);
            Contract.Requires(context != null);

            // TODO: path, package, and parent are not projectable from a module literal, but very useful for debugging.
            if (env.IsFileModule)
            {
                // TODO:ST: hide module instantiation from the clients!
                // This is last case when we need Id!
                UninstantiatedModuleInfo moduleInfo = context.ModuleRegistry.GetUninstantiatedModuleInfoByModuleId(env.Id);

                properties.AddRange(new[]
                {
                    new Property(":path", env.Path.ToDisplayString(context)),
                    new Property(":package", env.Package),
                    new Property(":qualifierSpace", GetQualifierSpaceValue(context, moduleInfo.QualifierSpaceId)),
                });
            }

            properties.Add(new Property(":parent", env.OuterScope));

            if (env.IsFileModule)
            {
                properties.Add(new Property("qualifier", env.Qualifier.Qualifier));
            }
        }
Example #12
0
 internal static ObjectInfo ObjectLiteralInfo(EvaluationContext context, ObjectLiteral objLit)
 {
     return(new ObjectInfo(
                "object{" + Invariant(objLit.Count) + "}",
                objLit.Members.Select(kvp => new Property(kvp.Key.ToString(context.StringTable), kvp.Value)).ToArray()));
 }
Example #13
0
        internal ObjectInfo GetObjectInfo(EvaluationContext context, object obj)
        {
            obj = obj is EvaluationResult evalResult ? evalResult.Value : obj;

            var result = IsInvalid(obj)
                ? s_nullObj
                : Match(obj, new CaseMatcher <ObjectInfo>[]
            {
                Case <ScopeLocals>(scope => new ObjectInfo(LocalsScopeName, null, Lazy.Create(() => GetLocalsForStackEntry(scope.EvalState, scope.FrameIndex)))),
                Case <ScopeCurrentModule>(scope => ModuleLiteralInfo(context, scope.Env).WithPreview(CurrentModuleScopeName)),
                Case <ScopePipGraph>(scope => PipGraphInfo(scope.Graph).WithPreview(PipGraphScopeName)),
                Case <ScopeAllModules>(scope => ArrayObjInfo(scope.EvaluatedModules).WithPreview(EvaluatedModulesScopeName)),
                Case <IModuleAndContext>(mc => GetObjectInfo(mc.Tree.RootContext, mc.Module)),
                Case <ObjectInfo>(objInf => objInf),
                Case <AmbientPlaceholder>(amb => new ObjectInfo(string.Empty, GetAmbientProperties(context, amb.Value).ToList())),
                Case <IPipGraph>(graph => PipGraphInfo(graph)),
                Case <Pip>(pip => GenericObjectInfo(pip, $"<{pip.PipType}>")),
                Case <PipProvenance>(prov => ProvenanceInfo(prov)),
                Case <EnvironmentVariable>(envVar => EnvironmentVariableInfo(envVar)),
                Case <PipFragment>(pipFrag => PipFragmentInfo(context, pipFrag)),
                Case <Thunk>(thunk => thunk.Value != null ? GetObjectInfo(context, thunk.Value) : new ObjectInfo("<not evaluated>")),
                Case <FunctionLikeExpression>(lambda => LambdaInfo(lambda)),
                Case <Closure>(cls => LambdaInfo(cls.Function)),
                Case <FullSymbol>(sym => new ObjectInfo(sym.ToString(context.FrontEndContext.SymbolTable))),
                Case <SymbolAtom>(sym => new ObjectInfo(sym.ToString(context.StringTable))),
                Case <StringId>(id => new ObjectInfo(id.ToString(context.StringTable))),
                Case <PipId>(id => new ObjectInfo($"{id.Value}")),
                Case <UndefinedLiteral>(_ => new ObjectInfo("undefined", UndefinedLiteral.Instance)),
                Case <UndefinedValue>(_ => new ObjectInfo("undefined", UndefinedValue.Instance)),
                Case <AbsolutePath>(path => new ObjectInfo($"p`{path.ToString(context.PathTable)}`", path)),
                Case <RelativePath>(path => new ObjectInfo($"r`{path.ToString(context.StringTable)}`", path)),
                Case <PathAtom>(atom => new ObjectInfo($"a`{atom.ToString(context.StringTable)}`", atom)),
                Case <FileArtifact>(file => new ObjectInfo($"f`{file.Path.ToString(context.PathTable)}`", file)),
                Case <DirectoryArtifact>(dir => new ObjectInfo($"d`{dir.Path.ToString(context.PathTable)}`", dir)),
                Case <uint>(num => new ObjectInfo($"{num}")),
                Case <short>(num => new ObjectInfo($"{num}", (int)num)),
                Case <long>(num => new ObjectInfo($"{num}")),
                Case <char>(ch => new ObjectInfo($"'{ch}'", ch.ToString())),
                Case <string>(str => new ObjectInfo($"\"{str}\"", str)),
                Case <Enum>(e => new ObjectInfo($"{e.GetType().Name}.{e}", e)),
                Case <NumberLiteral>(numLit => new ObjectInfo(numLit.UnboxedValue.ToString(), numLit)),
                Case <Func <object> >(func => FuncObjInfo(func)),
                Case <IEnumerable>(arr => ArrayObjInfo(arr.Cast <object>())),
                Case <ArrayLiteral>(arrLit => ArrayObjInfo(arrLit.Values.Select(v => v.Value)).WithOriginal(arrLit)),
                Case <ModuleBinding>(binding => GetObjectInfo(context, binding.Body)),
                Case <ModuleLiteral>(modLit => ModuleLiteralInfo(context, modLit)),
                Case <CallableValue>(cv => CallableValueInfo(context, cv).WithOriginal(cv)),
                Case <ErrorValue>(error => ErrorValueInfo(context)),
                Case <Package>(package => PackageInfo(context, package)),
                Case <ObjectLiteral>(objLit => ObjectLiteralInfo(context, objLit).WithOriginal(objLit)),
                Case <object>(o => o.GetType().IsArray
                        ? ArrayObjInfo(((IEnumerable)o).Cast <object>())
                        : PrimitiveObjInfo(context, o)),
            },
                        defaultResult: s_nullObj);

            var ambientProperties = obj is AmbientPlaceholder
                ? new Property[0]
                : new[] { new Property("__prototype__", new AmbientPlaceholder(obj)) };

            return(new ObjectInfo(result.Preview, result.Properties.Concat(ambientProperties).ToArray()));
        }