Exemple #1
0
        private bool BindInVariableAssignment(VariableAssignmentStatementNode variableAssignment,
                                              VariableIdentifierMap variableIdentifierMap)
        {
            TypeSymbolNode?assignedType = BindInExpression(variableAssignment.AssignedExpressionNode,
                                                           variableIdentifierMap);

            if (assignedType == null)
            {
                return(false);
            }

            if (!variableIdentifierMap.TryGet(variableAssignment.VariableIdentifier,
                                              out VariableSymbolNode? variable))
            {
                ErrorProvider.ReportError(ErrorCode.CantAssignUndeclaredVariable,
                                          Compilation,
                                          variableAssignment,
                                          $"Variable name: {variableAssignment.VariableIdentifier}");
                return(false);
            }

            if (variable.IsReadOnly)
            {
                ErrorProvider.ReportError(ErrorCode.CantReAssignReadOnlyVariable,
                                          Compilation,
                                          variableAssignment);
                return(false);
            }

            if (!TypeIsCompatibleWith(assignedType,
                                      variable.TypeNode,
                                      possiblyOffendingNode: variableAssignment.AssignedExpressionNode,
                                      out ImplicitConversionSymbolNode? conversion))
            {
                return(false);
            }

            variableAssignment.Bind(variable);

            if (conversion != null)
            {
                variableAssignment.AssignedExpressionNode.SpecifyImplicitConversion(conversion);
            }

            return(true);
        }
Exemple #2
0
        private bool BindInVariableDeclaration(VariableDeclarationStatementNode variableDeclaration,
                                               VariableIdentifierMap variableIdentifierMap)
        {
            if (variableIdentifierMap.TryGet(variableDeclaration.VariableIdentifier, out VariableSymbolNode? _))
            {
                ErrorProvider.ReportError(ErrorCode.CantRedeclareVariable,
                                          Compilation,
                                          variableDeclaration.VariableIdentifierNode);
                return(false);
            }

            VariableSymbolNode variable;

            if (variableDeclaration.AssignedExpressionNode != null)
            {
                TypeSymbolNode?assignedType = BindInExpression(variableDeclaration.AssignedExpressionNode,
                                                               variableIdentifierMap);

                if (assignedType == null)
                {
                    return(false);
                }

                if (variableDeclaration.TypeSpecNode == null)
                {
                    variable = variableDeclaration.CreateVariable(typeSymbol: assignedType);
                }
                else
                {
                    if (!typeManager.TryGetTypeSymbol(variableDeclaration.TypeSpecNode, out TypeSymbolNode? variableType))
                    {
                        return(false);
                    }
                    else if (!TypeIsCompatibleWith(assignedType,
                                                   variableType,
                                                   variableDeclaration.AssignedExpressionNode,
                                                   out ImplicitConversionSymbolNode? conversion))
                    {
                        return(false);
                    }
                    else
                    {
                        if (conversion != null)
                        {
                            variableDeclaration.AssignedExpressionNode.SpecifyImplicitConversion(conversion);
                        }

                        variable = variableDeclaration.CreateVariable(variableType);
                    }
                }
            }
            else
            {
                if (typeManager.TryGetTypeSymbol(variableDeclaration.TypeSpecNode, out TypeSymbolNode? variableType))
                {
                    variable = variableDeclaration.CreateVariable(variableType);
                }
                else
                {
                    return(false);
                }
            }

            variableIdentifierMap.AddSymbol(variableDeclaration.VariableIdentifier, variable);

            return(true);
        }