/// <inheritdoc /> public override bool TryProject(Context context, SymbolAtom name, ModuleLiteral origin, out EvaluationResult result, LineInfo location) { if (name == context.ContextTree.CommonConstants.Length) { result = EvaluationResult.Create(Length); return(true); } var resolvedMember = ((ModuleRegistry)context.FrontEndHost.ModuleRegistry).PredefinedTypes.AmbientArray.ResolveMember(this, name); if (resolvedMember == null) { // Array literals could not have arbitrary members. // So if the name was not resolved, reporting an error. // var locationForLogging = LocationForLogging(context, origin); var locationForLogging = UniversalLocation.FromLineInfo(location, origin.Path, context.PathTable); context.Logger.ReportMissingInstanceMember( context.LoggingContext, locationForLogging.AsLoggingLocation(), name.ToDisplayString(context), DisplayStringHelper.TypeToString(GetType(), context), context.GetStackTraceAsString(locationForLogging)); result = EvaluationResult.Error; } else { result = EvaluationResult.Create(resolvedMember); } return(true); }
/// <summary> /// Adds a namespace with a given name. /// </summary> internal virtual void AddNamespace(FullSymbol name, UniversalLocation location, QualifierSpaceId?qualifierSpaceId, out TypeOrNamespaceModuleLiteral module) { Contract.Requires(name.IsValid); Contract.Requires(Qualifier == QualifierValue.Unqualified); Contract.Assert(IsFileOrGlobal, "Current instance should be a file module or global ambient module"); lock (m_syncRoot) { m_nsBindings = m_nsBindings ?? new NsBindingDictionary(); if (m_nsBindings.ContainsKey(name)) { var moduleBinding = m_nsBindings[name]; Contract.Assert(moduleBinding.Body is TypeOrNamespaceModuleLiteral); module = (TypeOrNamespaceModuleLiteral)moduleBinding.Body; return; } module = CreateTypeOrNamespaceModule(name, outerScope: this, location: location.AsLineInfo()); // Module is always exported. m_nsBindings.Add(name, new ModuleBinding(module, Declaration.DeclarationFlags.Export, location.AsLineInfo())); } }
/// <inheritdoc /> internal override void AddType(FullSymbol name, UniversalLocation location, QualifierSpaceId?qualifierSpaceId, out TypeOrNamespaceModuleLiteral module) { module = CreateTypeOrNamespaceModule(name, outerScope: this, location: location.AsLineInfo()); Contract.Assert(qualifierSpaceId == null, "Only namespace support qualifier types"); AddResolvedEntry(location.AsFilePosition(), new ResolvedEntry(name, module)); }
/// <nodoc /> public ImportAliasExpression(DeserializationContext context, LineInfo location) : base(location) { var reader = context.Reader; m_referencedPath = reader.ReadAbsolutePath(); m_referencingLocation = new UniversalLocation(context, location); }
/// <summary> /// Constructor. /// </summary> /// <param name="referencedPath">Referenced absolute path to be aliased.</param> /// <param name="referencingLocation">Location of the expression. Includes absolute path for the file containing this expression, which may be consumed for error reporting.</param> public ImportAliasExpression(AbsolutePath referencedPath, UniversalLocation referencingLocation) : base(referencingLocation) { Contract.Requires(referencedPath.IsValid); m_referencedPath = referencedPath; m_referencingLocation = referencingLocation; }
/// <summary> /// Constructor which deserializes from the given DeserializationContext. /// </summary> public CoerceQualifierTypeExpression(DeserializationContext context, LineInfo location) : base(location) { TargetExpression = ReadExpression(context); TargetQualifierSpaceId = context.Reader.ReadQualifierSpaceId(); ShouldUseDefaultsOnCoercion = context.Reader.ReadBoolean(); ReferencedLocation = new UniversalLocation(context, location); }
/// <inheritdoc /> internal override void AddNamespace(FullSymbol name, UniversalLocation location, QualifierSpaceId?qualifierSpaceId, out TypeOrNamespaceModuleLiteral module) { module = CreateTypeOrNamespaceModule(name, outerScope: this, location: location.AsLineInfo()); Contract.Assert(qualifierSpaceId != null, "Qualifier type should be provided for a semantic evaluation"); m_moduleRegistry.AddUninstantiatedModuleInfo(new UninstantiatedModuleInfo(sourceFile: null, typeOrNamespaceLiteral: module, qualifierSpaceId: qualifierSpaceId.Value)); AddResolvedEntry(location.AsFilePosition(), new ResolvedEntry(name, module)); }
/// <nodoc /> private VariableDefinition(SymbolAtom name, int index, UniversalLocation locationDefinition, bool isConstant) { Contract.Requires(name.IsValid); Name = name; Index = index; LocationDefinition = locationDefinition; IsConstant = isConstant; }
/// <nodoc/> public CoerceQualifierTypeExpression(Expression targetExpression, QualifierSpaceId targetQualifierSpaceId, bool shouldUseDefault, LineInfo referencingLocation, UniversalLocation referencedLocation) : base(referencingLocation) { Contract.Requires(targetExpression != null, "targetExpression != null"); Contract.Requires(targetQualifierSpaceId.IsValid, "targetQualifierSpaceId.IsValid"); TargetExpression = targetExpression; TargetQualifierSpaceId = targetQualifierSpaceId; ShouldUseDefaultsOnCoercion = shouldUseDefault; ReferencedLocation = referencedLocation; }
private EvaluationResult ReportError(Context context, UnaryExpression spread) { var location = UniversalLocation.FromLineInfo(spread.Location, m_path, context.PathTable); context.Logger.ReportFailResolveSelectorDueToUndefined( context.LoggingContext, location.AsLoggingLocation(), spread.Expression.ToDisplayString(context), spread.ToDisplayString(context), context.GetStackTraceAsString(location)); return(EvaluationResult.Error); }
/// <summary> /// Adds a type with a given name. /// qualifierSpaceId is null for V1 and not null for v2. /// This is needed for a semantic-based evaluation and helps to filter nested variable declarations from the evaluation. /// </summary> internal virtual void AddType(FullSymbol name, UniversalLocation location, QualifierSpaceId?qualifierSpaceId, out TypeOrNamespaceModuleLiteral module) { AddNamespace(name, location, qualifierSpaceId, out module); }
public void TestCoerceQualifierTypeExpression() { CoerceQualifierTypeExpression node = new CoerceQualifierTypeExpression(GetExpression1(), m_qualifierSpaceId, false, DefaultLineInfo, UniversalLocation.FromLineInfo(DefaultLineInfo, GetAbsolutePath(), m_pathTable)); CheckSerializationRoundTrip(node); }
public void TestImportAliasExpression() { ImportAliasExpression node = new ImportAliasExpression(GetAbsolutePath(), UniversalLocation.FromLineInfo(DefaultLineInfo, GetAbsolutePath(), m_pathTable)); CheckSerializationRoundTrip(node); }
/// <inheritdoc/> public override void ReportError(EvaluationErrors errors, ModuleLiteral environment, LineInfo location, Expression expression, Context context) { errors.ReportContractFail(environment, Message, location, context.GetStackTraceAsString(UniversalLocation.FromLineInfo(location, environment.Path, context.PathTable))); }