Beispiel #1
0
        private void AddCycleInformation(Stack <DeclaredSymbol> symbolStack, DeclaredSymbol referencedDeclaration, IDictionary <SyntaxBase, ImmutableArray <DeclaredSymbol> > shortestCycleBySyntax)
        {
            var cycle = symbolStack
                        .TakeWhile(x => x != referencedDeclaration)
                        .Concat(new [] { referencedDeclaration })
                        .Reverse()
                        .ToImmutableArray();

            var cyclicSyntaxBySymbol = cycle
                                       .SelectMany(s => declarationAccessDict[s])
                                       .ToLookup(s => bindings[s]);

            foreach (var symbol in cycle)
            {
                foreach (var syntax in cyclicSyntaxBySymbol[symbol])
                {
                    if (shortestCycleBySyntax.TryGetValue(syntax, out var otherCycle) && otherCycle.Length <= cycle.Length)
                    {
                        // we've already found a shorter cycle
                        continue;
                    }

                    shortestCycleBySyntax[syntax] = cycle;
                }
            }
        }
Beispiel #2
0
        private void EmitDependsOn(DeclaredSymbol declaredSymbol)
        {
            var dependencies = context.ResourceDependencies[declaredSymbol];

            if (!dependencies.Any())
            {
                return;
            }

            writer.WritePropertyName("dependsOn");
            writer.WriteStartArray();
            // need to put dependencies in a deterministic order to generate a deterministic template
            foreach (var dependency in dependencies.OrderBy(x => x.Name))
            {
                switch (dependency)
                {
                case ResourceSymbol resourceDependency:
                    var typeReference = EmitHelpers.GetTypeReference(resourceDependency);
                    emitter.EmitResourceIdReference(resourceDependency.DeclaringResource, typeReference);
                    break;

                case ModuleSymbol moduleDependency:
                    emitter.EmitModuleResourceIdExpression(moduleDependency);
                    break;

                default:
                    throw new InvalidOperationException($"Found dependency '{dependency.Name}' of unexpected type {dependency.GetType()}");
                }
            }
            writer.WriteEndArray();
        }
Beispiel #3
0
        private void Substitute(DeclaredSymbol localSymbol, Dictionary <string, Expr> symbolExprs, bool src)
        {
            if (!(localSymbol is DeclaredVariableSymbol localVarSymbol))
            {
                return;
            }
            foreach ((string _, DeclaredSymbol symbol) in src ? this.srcSymbols : this.dstSymbols)
            {
                Expr replacement = localSymbol.GetInitSymbolValue(symbolExprs);
                switch (symbol)
                {
                case DeclaredVariableSymbol var:
                    var.SymbolicInitializer = var.SymbolicInitializer?.Substitute(localSymbol.Identifier, replacement);
                    break;

                case DeclaredArraySymbol arr:
                    // TODO
                    break;

                case DeclaredFunctionSymbol f:
                    // TODO
                    break;
                }
            }
        }
        private SymbolKind SelectSymbolKind(DeclaredSymbol symbol)
        {
            switch (symbol)
            {
            case ImportedNamespaceSymbol _:
                return(SymbolKind.Namespace);

            case ParameterSymbol _:
                return(SymbolKind.Field);

            case VariableSymbol _:
                return(SymbolKind.Variable);

            case ResourceSymbol resource:
                return(SymbolKind.Object);

            case ModuleSymbol module:
                return(SymbolKind.Module);

            case OutputSymbol output:
                return(SymbolKind.Interface);

            default:
                return(SymbolKind.Key);
            }
        }
 private DocumentSymbol CreateDocumentSymbol(DeclaredSymbol symbol, ImmutableArray <int> lineStarts) =>
 new DocumentSymbol
 {
     Name   = symbol.Name,
     Kind   = SelectSymbolKind(symbol),
     Detail = FormatDetail(symbol),
     Range  = symbol.DeclaringSyntax.ToRange(lineStarts),
     // use the name node span with fallback to entire declaration span
     SelectionRange = symbol.NameSyntax.ToRange(lineStarts)
 };
Beispiel #6
0
 public Members(DeclaredSymbol symbol, SymbolCompletionState state,
                ImmutableArray <Symbol> nonTypeMembers, ImmutableArray <NamedTypeSymbol> typeMembers)
 {
     Debug.Assert(!nonTypeMembers.IsDefault);
     Debug.Assert(!typeMembers.IsDefault);
     Debug.Assert(!nonTypeMembers.Any(s => s is ITypeSymbol));
     Debug.Assert(!typeMembers.Any(s => !(s is ITypeSymbol)));
     _symbol = symbol;
     _state  = state;
     this.NamedNonTypeMembers     = nonTypeMembers.WhereAsArray(m => m.Name != null);
     this.NamedTypeMembers        = typeMembers.WhereAsArray(m => m.Name != null);
     this.AnonymousNonTypeMembers = nonTypeMembers.WhereAsArray(m => m.Name == null);
     this.AnonymousTypeMembers    = typeMembers.WhereAsArray(m => m.Name == null);
 }
Beispiel #7
0
        protected void CompareSymbols(Dictionary <string, DeclaredSymbol> srcSymbols, Dictionary <string, DeclaredSymbol> dstSymbols)
        {
            Log.Debug("Testing declarations...");

            foreach ((string identifier, DeclaredSymbol srcSymbol) in srcSymbols)
            {
                if (identifier.StartsWith("tmp__"))
                {
                    continue;
                }

                if (!dstSymbols.ContainsKey(identifier))
                {
                    this.Issues.AddWarning(new MissingDeclarationWarning(srcSymbol.Specifiers, srcSymbol.Declarator));
                    continue;
                }
                DeclaredSymbol dstSymbol = dstSymbols[identifier];

                if (srcSymbol.Specifiers != dstSymbol.Specifiers)
                {
                    this.Issues.AddWarning(new DeclSpecsMismatchWarning(dstSymbol.Declarator, srcSymbol.Specifiers, dstSymbol.Specifiers));
                }

                var declComparer = new DeclNodeComparer(srcSymbol, dstSymbol);
                this.Issues.Add(declComparer.Compare(srcSymbol.Declarator, dstSymbol.Declarator));
            }

            foreach (string identifier in dstSymbols.Keys.Except(srcSymbols.Keys))
            {
                if (!identifier.StartsWith("tmp__"))
                {
                    DeclaredSymbol extra = dstSymbols[identifier];
                    this.Issues.AddWarning(new ExtraDeclarationWarning(extra.Specifiers, extra.Declarator));
                }
            }

            if (!this.Issues.NoSeriousIssues)
            {
                Log.Error("Failed to match found declarations to all expected declarations.");
            }
            else
            {
                Log.Debug("Matched all expected top-level declarations.");
            }
        }
        private Dictionary <string, DeclaredSymbol> GetDeclaredSymbols(DeclStatNode node)
        {
            var symbols = new Dictionary <string, DeclaredSymbol>();

            foreach (DeclNode decl in node.DeclaratorList.Declarators)
            {
                var symbol = DeclaredSymbol.From(node.Specifiers, decl);
                if (symbol is DeclaredFunctionSymbol df && symbols.ContainsKey(df.Identifier))
                {
                    if (!df.AddOverload(df.FunctionDeclarator))
                    {
                        throw new SemanticErrorException($"Multiple overloads with same parameters found for function: {df.Identifier}", decl.Line);
                    }
                }
                symbols.Add(decl.Identifier, symbol);
            }

            return(symbols);
        }
        public SourceMemberContainerTypeSymbol(
            DeclaredSymbol containingSymbol,
            MergedDeclaration declaration,
            DiagnosticBag diagnostics)
        {
            _containingSymbol = containingSymbol;
            _declaration      = declaration;

            if (declaration.Kind != null)
            {
                _modelObject = declaration.GetModelObject(containingSymbol?.ModelObject as MutableObjectBase, containingSymbol.ModelBuilder, diagnostics);
                Debug.Assert(_modelObject != null);
            }

            foreach (var singleDeclaration in declaration.Declarations)
            {
                diagnostics.AddRange(singleDeclaration.Diagnostics);
            }
            _state = SymbolCompletionState.Create(containingSymbol.Language);
        }
Beispiel #10
0
        private string FormatDetail(DeclaredSymbol symbol)
        {
            switch (symbol)
            {
            case ParameterSymbol parameter:
                return(parameter.Type.Name);

            case VariableSymbol variable:
                return(variable.Type.Name);

            case ResourceSymbol resource:
                return(resource.Type.Name);

            case OutputSymbol output:
                return(output.Type.Name);

            default:
                return(string.Empty);
            }
        }
Beispiel #11
0
 public ResourceDependency(DeclaredSymbol resource, SyntaxBase?indexExpression, ResourceDependencyKind kind)
 {
     this.Resource        = resource;
     this.IndexExpression = indexExpression;
     this.Kind            = kind;
 }
Beispiel #12
0
 public ResourceDependency(DeclaredSymbol resource, SyntaxBase? indexExpression)
 {
     this.Resource = resource;
     this.IndexExpression = indexExpression;
 }
Beispiel #13
0
        protected virtual void SetPropertyValues(DeclaredSymbol symbol, DiagnosticBag diagnostics, CancellationToken cancellationToken)
        {
            var properties  = this.GetProperties(null, cancellationToken);
            var modelObject = (MutableObjectBase)symbol.ModelObject;

            if (modelObject == null)
            {
                return;
            }
            foreach (var boundProperty in properties)
            {
                string name = boundProperty.Name;
                var    prop = modelObject.MGetProperty(name);
                if (prop == null)
                {
                    diagnostics.Add(ModelErrorCode.ERR_PropertyDoesNotExist, boundProperty.Location, modelObject, name);
                    continue;
                }
                //if (prop.IsBaseScope) continue;
                var propValues = ArrayBuilder <BoundValues> .GetInstance();

                boundProperty.AddValues(propValues, boundProperty, boundProperty, cancellationToken);
                foreach (var boundValue in propValues)
                {
                    //if (boundValue is BoundSymbolDef) continue; // TODO:MetaDslx - prevent values to be added multiple times
                    if (prop.IsCollection)
                    {
                        var values = boundValue.Values.Select(v => v is Symbol symbolValue ? symbolValue.ModelObject : v).ToArray();
                        try
                        {
                            modelObject.MAddRange(prop, values);
                        }
                        catch (ModelException me)
                        {
                            diagnostics.Add(ModelErrorCode.ERR_CannotAddValuesToProperty, this.Location, prop, modelObject, me.ToString());
                        }
                    }
                    else
                    {
                        if (boundValue.Values.Length == 1)
                        {
                            var value = boundValue.Values[0];
                            if (value is Symbol symbolValue)
                            {
                                value = symbolValue.ModelObject;
                            }
                            try
                            {
                                modelObject.MSet(prop, value);
                            }
                            catch (ModelException me)
                            {
                                diagnostics.Add(ModelErrorCode.ERR_CannotSetValueToProperty, this.Location, prop, modelObject, me.ToString());
                            }
                        }
                        else if (boundValue.Values.Length > 1)
                        {
                            diagnostics.Add(ModelErrorCode.ERR_CannotAddMultipleValuesToNonCollectionProperty, this.Location, prop, modelObject);
                        }
                    }
                }
                propValues.Free();
            }
        }
Beispiel #14
0
 public MembersBuilder(DeclaredSymbol symbol, SymbolCompletionState state)
 {
     _symbol = symbol;
     _state  = state;
 }
Beispiel #15
0
 public SourceNamedTypeSymbol(DeclaredSymbol containingSymbol, MergedDeclaration declaration, DiagnosticBag diagnostics)
     : base(containingSymbol, declaration, diagnostics)
 {
     Debug.Assert(!declaration.IsImplicit && !declaration.IsSubmission && !declaration.IsScript);
 }
Beispiel #16
0
 public DeclNodeComparer(DeclaredSymbol sym1, DeclaredSymbol sym2)
 {
     this.Symbol1 = sym1;
     this.Symbol2 = sym2;
 }
Beispiel #17
0
        private static string?TryGetDescriptionMarkdown(SymbolResolutionResult result, DeclaredSymbol symbol)
        {
            if (symbol.DeclaringSyntax is StatementSyntax statementSyntax &&
                SemanticModelHelper.TryGetDescription(result.Context.Compilation.GetEntrypointSemanticModel(), statementSyntax) is { } description)
            {
                return(description);
            }

            return(null);
        }
Beispiel #18
0
 public SourceAnonymousTypeSymbol(DeclaredSymbol containingSymbol, MergedDeclaration declaration, DiagnosticBag diagnostics)
     : base(containingSymbol, declaration, diagnostics)
 {
 }
Beispiel #19
0
        private TypeSymbol HandleSymbolType(string symbolName, TextSpan symbolNameSpan, DeclaredSymbol declaringType)
        {
            // symbols are responsible for doing their own type checking
            // the error from that should not be propagated to expressions that have type errors
            // unless we're dealing with a cyclic expression error, then propagate away!
            if (declaringType.Type is ErrorTypeSymbol errorType)
            {
                // replace the original error with a different one
                // we may consider suppressing this error in the future as well
                return(new ErrorTypeSymbol(DiagnosticBuilder.ForPosition(symbolNameSpan).ReferencedSymbolHasErrors(symbolName)));
            }

            return(declaringType.Type);
        }
 public SourceDeclaration(DeclaredSymbol symbol, MergedDeclaration declaration, SymbolCompletionState state)
 {
     _symbol      = symbol;
     _state       = state;
     _declaration = declaration;
 }