Esempio n. 1
0
        private static bool ExceptionListConformToBase(IList <IIdentifier> derivedExceptionIdentifierList, IList <IIdentifier> baseExceptionIdentifierList, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            if (derivedExceptionIdentifierList.Count > baseExceptionIdentifierList.Count)
            {
                errorList.AddError(new ErrorExceptionConformance(sourceLocation, derivedExceptionIdentifierList, baseExceptionIdentifierList));
                Result = false;
            }

            bool AllIdentifiersMatch = true;

            for (int i = 0; i < derivedExceptionIdentifierList.Count; i++)
            {
                IIdentifier DerivedIdentifier = derivedExceptionIdentifierList[i];

                bool Found = false;
                for (int j = 0; j < baseExceptionIdentifierList.Count; j++)
                {
                    IIdentifier BaseIdentifier = baseExceptionIdentifierList[j];
                    Found |= DerivedIdentifier.ValidText.Item == BaseIdentifier.ValidText.Item;
                }

                AllIdentifiersMatch &= Found;
            }

            if (!AllIdentifiersMatch)
            {
                errorList.AddError(new ErrorExceptionConformance(sourceLocation, derivedExceptionIdentifierList, baseExceptionIdentifierList));
                Result = false;
            }

            return(Result);
        }
Esempio n. 2
0
        /// <summary>
        /// Merges a class import with previous imports.
        /// </summary>
        /// <param name="importedClassTable">The already resolved imports.</param>
        /// <param name="mergedClassTable">The new classes to import.</param>
        /// <param name="importLocation">The import location.</param>
        /// <param name="mergedImportType">The import specification for all <paramref name="mergedClassTable"/>.</param>
        /// <param name="errorList">List of errors found.</param>
        /// <returns>True if the merge is successful.</returns>
        public static bool MergeClassTables(ISealableDictionary <string, IImportedClass> importedClassTable, ISealableDictionary <string, IImportedClass> mergedClassTable, IImport importLocation, BaseNode.ImportType mergedImportType, IErrorList errorList)
        {
            bool Success = true;

            foreach (KeyValuePair <string, IImportedClass> Entry in mergedClassTable)
            {
                string         ClassName       = Entry.Key;
                IImportedClass MergedClassItem = Entry.Value;

                // The merged class may have an import specification already, but if so it must match the one used here.
                // We can assume we use mergedImportType after this.
                if (MergedClassItem.IsTypeAssigned && MergedClassItem.ImportType != mergedImportType)
                {
                    errorList.AddError(new ErrorImportTypeConflict(importLocation, ClassName));
                    Success = false;
                }

                // If a class is already imported with this name somehow.
                if (importedClassTable.ContainsKey(ClassName))
                {
                    // It must be the same class.
                    IImportedClass ClassItem = importedClassTable[ClassName];
                    if (ClassItem.Item != MergedClassItem.Item)
                    {
                        errorList.AddError(new ErrorNameAlreadyUsed(importLocation, ClassName));
                        Success = false;
                        continue;
                    }

                    // If the already existing imported class has a specification, it must match the one use for merge.
                    if (ClassItem.IsTypeAssigned)
                    {
                        if (ClassItem.ImportType != mergedImportType)
                        {
                            errorList.AddError(new ErrorImportTypeConflict(importLocation, ClassName));
                            Success = false;
                            continue;
                        }
                    }
                    else
                    {
                        ClassItem.SetImportType(mergedImportType);
                    }

                    // If the import location isn't specified yet, use the imported library.
                    if (!ClassItem.IsLocationAssigned)
                    {
                        ClassItem.SetImportLocation(importLocation);
                    }
                }
                else
                {
                    // New class, at least by name. Make sure it's not an already imported class using a different name.
                    Success &= MergeClassTablesWithNewClass(importedClassTable, ClassName, MergedClassItem, importLocation, mergedImportType, errorList);
                }
            }

            Debug.Assert(Success || !errorList.IsEmpty);
            return(Success);
        }
Esempio n. 3
0
        private static bool PositionalArgumentsConformToParameters(IList <ISealableList <IParameter> > parameterTableList, IReadOnlyList <IExpressionType> arguments, IErrorList errorList, ISource source, out int selectedIndex)
        {
            ISealableList <IParameter> SelectedOverload = null;

            selectedIndex = -1;
            int MaximumAllowedArgumentCount = -1;

            for (int i = 0; i < parameterTableList.Count; i++)
            {
                PositionalArgumentMatching(parameterTableList, arguments, i, ref MaximumAllowedArgumentCount, ref SelectedOverload, ref selectedIndex);
            }

            if (MaximumAllowedArgumentCount >= 0 && MaximumAllowedArgumentCount < arguments.Count)
            {
                errorList.AddError(new ErrorTooManyArguments(source, arguments.Count, MaximumAllowedArgumentCount));
                return(false);
            }

            if (SelectedOverload == null)
            {
                errorList.AddError(new ErrorInvalidExpression(source));
                return(false);
            }

            Debug.Assert(SelectedOverload.Count >= arguments.Count);

            return(true);
        }
Esempio n. 4
0
        private static bool FormalGenericTypeConformToBase(IFormalGenericType derivedType, ICompiledType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Result &= derivedType.FormalGeneric.ResolvedConformanceTable.IsSealed;

            if (derivedType.FormalGeneric.ResolvedConformanceTable.Count > 0)
            {
                Result &= FormalGenericTypeConformToBaseWithConformance(derivedType, baseType, errorList, sourceLocation);
            }
            else if (baseType != ClassType.ClassAnyType && baseType != ClassType.ClassAnyReferenceType && baseType != ClassType.ClassAnyValueType)
            {
                errorList.AddError(new ErrorInsufficientConstraintConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            if (baseType.IsReference && !derivedType.IsReference)
            {
                errorList.AddError(new ErrorReferenceValueConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            if (baseType.IsValue && !derivedType.IsValue)
            {
                errorList.AddError(new ErrorReferenceValueConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            return(Result);
        }
Esempio n. 5
0
        private static bool TypeConformToFormalGenericType(ICompiledType derivedType, IFormalGenericType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Result &= baseType.FormalGeneric.ResolvedConformanceTable.IsSealed;

            foreach (KeyValuePair <ITypeName, ICompiledType> ConformingEntry in baseType.FormalGeneric.ResolvedConformanceTable)
            {
                ICompiledType ConformingType = ConformingEntry.Value;
                Result &= TypeConformToBase(derivedType, ConformingType, errorList, sourceLocation, isConversionAllowed: false);
            }

            if (!derivedType.IsReference && baseType.IsReference)
            {
                errorList.AddError(new ErrorReferenceValueConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            if (!derivedType.IsValue && baseType.IsValue)
            {
                errorList.AddError(new ErrorReferenceValueConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            return(Result);
        }
Esempio n. 6
0
        private static bool ProcedureTypeConformToIndexerType(IProcedureType derivedType, IIndexerType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
            Debug.Assert(baseType.ResolvedBaseType.IsAssigned);

            Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false);

            if (baseType.IndexerKind != BaseNode.UtilityType.WriteOnly)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            bool MatchingOverload = false;

            foreach (ICommandOverloadType DerivedOverload in derivedType.OverloadList)
            {
                MatchingOverload |= ProcedureTypeConformToIndexerTypeOverloads(DerivedOverload, baseType, errorList, sourceLocation);
            }

            if (!MatchingOverload)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            return(Result);
        }
Esempio n. 7
0
        private static bool FunctionTypeConformToFunctionType(IFunctionType derivedType, IFunctionType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
            Debug.Assert(baseType.ResolvedBaseType.IsAssigned);

            if (!TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false))
            {
                errorList.AddError(new ErrorBaseConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            foreach (IQueryOverloadType BaseOverload in baseType.OverloadList)
            {
                bool MatchingDerivedOverload = false;
                foreach (IQueryOverloadType DerivedOverload in derivedType.OverloadList)
                {
                    MatchingDerivedOverload |= QueryOverloadConformToBase(DerivedOverload, BaseOverload, ErrorList.Ignored, ErrorList.NoLocation);
                }

                if (!MatchingDerivedOverload)
                {
                    errorList.AddError(new ErrorOverloadMismatchConformance(sourceLocation, derivedType, baseType));
                    Result = false;
                }
            }

            return(Result);
        }
Esempio n. 8
0
        /// <summary>
        /// Initializes the list of classes belonging to the library.
        /// </summary>
        /// <param name="classTable">Valid class names.</param>
        /// <param name="errorList">List of errors found.</param>
        /// <returns>True if initialization succeeded.</returns>
        public virtual bool InitLibraryTables(ISealableDictionary <string, ISealableDictionary <string, IClass> > classTable, IErrorList errorList)
        {
            bool Success = true;

            foreach (IIdentifier ClassIdentifier in ClassIdentifierList)
            {
                // Verify the class identifier is a valid string.
                if (!StringValidation.IsValidIdentifier(ClassIdentifier, ClassIdentifier.Text, out string ValidClassIdentifier, out IErrorStringValidity StringError))
                {
                    Success = false;
                    errorList.AddError(StringError);
                    continue;
                }

                if (ValidClassIdentifier.ToUpperInvariant() == LanguageClasses.Any.Name.ToUpperInvariant())
                {
                    // 'Any' is implicit and just ignored.
                }
                else
                {
                    // Check that the class name is known.
                    if (!classTable.ContainsKey(ValidClassIdentifier))
                    {
                        Success = false;
                        errorList.AddError(new ErrorUnknownIdentifier(ClassIdentifier, ValidClassIdentifier));
                        continue;
                    }

                    ISealableDictionary <string, IClass> SourceNameTable = classTable[ValidClassIdentifier];

                    // And it's from the same source.
                    if (!SourceNameTable.ContainsKey(ValidSourceName))
                    {
                        Success = false;
                        errorList.AddError(new ErrorUnknownIdentifier(ClassIdentifier, ValidClassIdentifier));
                        continue;
                    }

                    // The class must be imported only once.
                    if (ImportedClassTable.ContainsKey(ValidClassIdentifier))
                    {
                        Success = false;
                        errorList.AddError(new ErrorIdentifierAlreadyListed(ClassIdentifier, ValidClassIdentifier));
                        continue;
                    }

                    // Add it, leaving the import mode open for now.
                    IImportedClass Imported = new ImportedClass(SourceNameTable[ValidSourceName]);
                    ImportedClassTable.Add(ValidClassIdentifier, Imported);

#if COVERAGE
                    string ImportString = Imported.ToString();
#endif
                }
            }

            Debug.Assert(Success || !errorList.IsEmpty);
            return(Success);
        }
Esempio n. 9
0
        private static bool IndexerTypeConformToProcedureType(IIndexerType derivedType, IProcedureType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
            Debug.Assert(baseType.ResolvedBaseType.IsAssigned);

            Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false);

            if (derivedType.IndexerKind == BaseNode.UtilityType.ReadOnly)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            if (baseType.OverloadList.Count > 1)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            ICommandOverloadType SingleOverload = baseType.OverloadList[0];

            if (SingleOverload.ParameterList.Count != derivedType.IndexParameterList.Count + 1 || SingleOverload.ParameterEnd != BaseNode.ParameterEndStatus.Closed)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            for (int i = 0; i + 1 < SingleOverload.ParameterList.Count && i < derivedType.IndexParameterList.Count; i++)
            {
                IEntityDeclaration BaseParameter    = SingleOverload.ParameterList[i];
                IEntityDeclaration DerivedParameter = derivedType.IndexParameterList[i];

                Debug.Assert(BaseParameter.ValidEntity.IsAssigned);
                Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
                Debug.Assert(DerivedParameter.ValidEntity.IsAssigned);
                Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);

                Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
            }

            if (SingleOverload.ParameterList.Count == derivedType.IndexParameterList.Count + 1)
            {
                Debug.Assert(derivedType.ResolvedEntityType.IsAssigned);

                IEntityDeclaration LastParameter = SingleOverload.ParameterList[derivedType.IndexParameterList.Count];
                Debug.Assert(LastParameter.ValidEntity.IsAssigned);
                Debug.Assert(LastParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);

                Result &= TypeConformToBase(derivedType.ResolvedEntityType.Item, LastParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
            }

            Result &= ExceptionListConformToBase(derivedType.SetExceptionIdentifierList, SingleOverload.ExceptionIdentifierList, errorList, sourceLocation);

            return(Result);
        }
        /// <summary>
        /// Finds the matching nodes of a <see cref="IClassConstantExpression"/>.
        /// </summary>
        /// <param name="node">The agent expression to check.</param>
        /// <param name="errorList">The list of errors found.</param>
        /// <param name="resolvedResult">The expression result types upon return.</param>
        /// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
        /// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
        /// <param name="expressionConstant">The expression constant upon return.</param>
        /// <param name="resolvedFinalFeature">The feature if the end of the path is a feature.</param>
        /// <param name="resolvedFinalDiscrete">The discrete if the end of the path is a discrete.</param>
        /// <param name="resolvedClassTypeName">The class type name upon return.</param>
        /// <param name="resolvedClassType">The class name upon return.</param>
        public static bool ResolveCompilerReferences(IClassConstantExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out IConstantFeature resolvedFinalFeature, out IDiscrete resolvedFinalDiscrete, out ITypeName resolvedClassTypeName, out IClassType resolvedClassType)
        {
            resolvedResult        = null;
            resolvedException     = null;
            constantSourceList    = new SealableList <IExpression>();
            expressionConstant    = NeutralLanguageConstant.NotConstant;
            resolvedFinalFeature  = null;
            resolvedFinalDiscrete = null;
            resolvedClassTypeName = null;
            resolvedClassType     = null;

            IIdentifier ClassIdentifier    = (IIdentifier)node.ClassIdentifier;
            IIdentifier ConstantIdentifier = (IIdentifier)node.ConstantIdentifier;
            IClass      EmbeddingClass     = node.EmbeddingClass;
            string      ValidClassText     = ClassIdentifier.ValidText.Item;
            string      ValidConstantText  = ConstantIdentifier.ValidText.Item;
            ISealableDictionary <string, IImportedClass> ClassTable = EmbeddingClass.ImportedClassTable;

            if (!ClassTable.ContainsKey(ValidClassText))
            {
                errorList.AddError(new ErrorUnknownIdentifier(ClassIdentifier, ValidClassText));
                return(false);
            }

            IClass BaseClass = ClassTable[ValidClassText].Item;

            resolvedClassTypeName = BaseClass.ResolvedClassTypeName.Item;
            resolvedClassType     = BaseClass.ResolvedClassType.Item;

            ITypeName     ConstantTypeName;
            ICompiledType ConstantType;

            ISealableDictionary <IFeatureName, IDiscrete>        DiscreteTable = BaseClass.DiscreteTable;
            ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable  = BaseClass.FeatureTable;

            if (FeatureName.TableContain(DiscreteTable, ValidConstantText, out IFeatureName Key, out IDiscrete Discrete))
            {
                if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType))
                {
                    errorList.AddError(new ErrorNumberTypeMissing(node));
                    return(false);
                }

                if (Discrete.NumericValue.IsAssigned)
                {
                    constantSourceList.Add((IExpression)Discrete.NumericValue.Item);
                }
                else
                {
                    expressionConstant = new DiscreteLanguageConstant(Discrete);
                }

                resolvedFinalDiscrete = Discrete;
                ConstantTypeName      = NumberTypeName;
                ConstantType          = NumberType;
            }
Esempio n. 11
0
        private static bool CheckAssignemntIdentifier(IErrorList errorList, ISealableDictionary <IFeatureName, IFeatureInstance> featureTable, ISealableDictionary <string, ICompiledFeature> assignedFeatureTable, IIdentifier identifierItem)
        {
            bool   Success             = true;
            string ValidIdentifierText = identifierItem.ValidText.Item;

            if (assignedFeatureTable.ContainsKey(ValidIdentifierText))
            {
                errorList.AddError(new ErrorIdentifierAlreadyListed(identifierItem, ValidIdentifierText));
                Success = false;
            }
            else
            {
                if (FeatureName.TableContain(featureTable, ValidIdentifierText, out IFeatureName Key, out IFeatureInstance FeatureItem))
                {
                    bool ValidFeature = false;

                    if (FeatureItem.Feature is AttributeFeature AsAttributeFeature)
                    {
                        ValidFeature = true;
                    }
                    else if (FeatureItem.Feature is IPropertyFeature AsPropertyFeature)
                    {
                        bool IsHandled = false;
                        switch (AsPropertyFeature.PropertyKind)
                        {
                        case BaseNode.UtilityType.ReadOnly:
                            ValidFeature = !AsPropertyFeature.GetterBody.IsAssigned;
                            IsHandled    = true;
                            break;

                        case BaseNode.UtilityType.ReadWrite:
                            ValidFeature = !(AsPropertyFeature.GetterBody.IsAssigned && !AsPropertyFeature.SetterBody.IsAssigned);
                            IsHandled    = true;
                            break;

                        case BaseNode.UtilityType.WriteOnly:
                            ValidFeature = true;
                            IsHandled    = true;
                            break;
                        }

                        Debug.Assert(IsHandled);
                    }

                    if (ValidFeature)
                    {
                        assignedFeatureTable.Add(ValidIdentifierText, FeatureItem.Feature);
                    }
                    else
                    {
                        errorList.AddError(new ErrorAttributeOrPropertyRequired(identifierItem, ValidIdentifierText));
                        Success = false;
                    }
                }
Esempio n. 12
0
        private static bool IndexerTypeConformToIndexerType(IIndexerType derivedType, IIndexerType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
            Debug.Assert(baseType.ResolvedBaseType.IsAssigned);

            Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false);

            if ((baseType.IndexerKind == BaseNode.UtilityType.ReadOnly && derivedType.IndexerKind == BaseNode.UtilityType.WriteOnly) ||
                (baseType.IndexerKind == BaseNode.UtilityType.WriteOnly && derivedType.IndexerKind == BaseNode.UtilityType.ReadOnly) ||
                (baseType.IndexerKind == BaseNode.UtilityType.ReadWrite && derivedType.IndexerKind != BaseNode.UtilityType.ReadWrite))
            {
                errorList.AddError(new ErrorGetterSetterConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            if (derivedType.IndexParameterList.Count != baseType.IndexParameterList.Count || derivedType.ParameterEnd != baseType.ParameterEnd)
            {
                errorList.AddError(new ErrorParameterMismatchConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            for (int i = 0; i < baseType.IndexParameterList.Count && i < derivedType.IndexParameterList.Count; i++)
            {
                IEntityDeclaration BaseParameter    = baseType.IndexParameterList[i];
                IEntityDeclaration DerivedParameter = derivedType.IndexParameterList[i];

                Debug.Assert(DerivedParameter.ValidEntity.IsAssigned);
                Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
                Debug.Assert(BaseParameter.ValidEntity.IsAssigned);
                Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);

                Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
            }

            Debug.Assert(derivedType.ResolvedEntityType.IsAssigned);
            Debug.Assert(baseType.ResolvedEntityType.IsAssigned);

            Result &= TypeConformToBase(derivedType.ResolvedEntityType.Item, baseType.ResolvedEntityType.Item, errorList, sourceLocation, isConversionAllowed: false);

            /*
             * if (!TypesHaveIdenticalSignature(derivedType.ResolvedEntityType.Item, baseType.ResolvedEntityType.Item))
             * {
             *  //errorList.Add(new ConformanceError(sourceLocation));
             *  return false;
             * }
             */

            Result &= ExceptionListConformToBase(derivedType.GetExceptionIdentifierList, baseType.GetExceptionIdentifierList, errorList, sourceLocation);
            Result &= ExceptionListConformToBase(derivedType.SetExceptionIdentifierList, baseType.SetExceptionIdentifierList, errorList, sourceLocation);

            return(Result);
        }
Esempio n. 13
0
        private static bool IndexerTypeConformToFunctionType(IIndexerType derivedType, IFunctionType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
            Debug.Assert(baseType.ResolvedBaseType.IsAssigned);

            Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false);

            if (derivedType.IndexerKind == BaseNode.UtilityType.WriteOnly)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            if (baseType.OverloadList.Count > 1)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            IQueryOverloadType SingleOverload = baseType.OverloadList[0];

            if (SingleOverload.ParameterList.Count != derivedType.IndexParameterList.Count || SingleOverload.ResultList.Count != 1 || SingleOverload.ParameterEnd != derivedType.ParameterEnd)
            {
                errorList.AddError(new ErrorTypeKindConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            for (int i = 0; i < SingleOverload.ParameterList.Count && i < derivedType.IndexParameterList.Count; i++)
            {
                IEntityDeclaration BaseParameter    = SingleOverload.ParameterList[i];
                IEntityDeclaration DerivedParameter = derivedType.IndexParameterList[i];

                Debug.Assert(DerivedParameter.ValidEntity.IsAssigned);
                Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
                Debug.Assert(BaseParameter.ValidEntity.IsAssigned);
                Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);

                Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
            }

            IEntityDeclaration OverloadResult = SingleOverload.ResultList[0];

            Debug.Assert(OverloadResult.ValidEntity.IsAssigned);
            Debug.Assert(OverloadResult.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
            Debug.Assert(derivedType.ResolvedEntityType.IsAssigned);

            Result &= TypeConformToBase(OverloadResult.ValidEntity.Item.ResolvedEffectiveType.Item, derivedType.ResolvedEntityType.Item, errorList, sourceLocation, isConversionAllowed: false);
            Result &= ExceptionListConformToBase(derivedType.GetExceptionIdentifierList, SingleOverload.ExceptionIdentifierList, errorList, sourceLocation);

            return(Result);
        }
        private bool CheckPrecursorSelected(ISealableDictionary <IFeatureName, InheritedInstanceInfo> byNameTable, ISealableDictionary <IFeatureName, IList <ICompiledFeature> > precursorSet, IErrorList errorList)
        {
            bool Success = true;
            bool IsKept  = false;

            foreach (KeyValuePair <IFeatureName, IList <ICompiledFeature> > SetMemberEntry in precursorSet)
            {
                IFeatureName          SetMemberKey          = SetMemberEntry.Key;
                InheritedInstanceInfo CorrespondingInstance = byNameTable[SetMemberKey];

                if (CorrespondingInstance.IsKept)
                {
                    if (IsKept)
                    {
                        foreach (InstanceNameInfo Item in CorrespondingInstance.PrecursorInstanceList)
                        {
                            if (Item.Instance.IsKept)
                            {
                                errorList.AddError(new ErrorInheritanceConflict(Item.Location, Item.Name.Name));
                                Success = false;
                                break;
                            }
                        }
                    }
                    else
                    {
                        IsKept = true;
                    }
                }
            }

            if (!IsKept && precursorSet.Count > 1)
            {
                foreach (KeyValuePair <IFeatureName, IList <ICompiledFeature> > SetMemberEntry in precursorSet)
                {
                    IFeatureName          SetMemberKey          = SetMemberEntry.Key;
                    InheritedInstanceInfo CorrespondingInstance = byNameTable[SetMemberKey];

                    foreach (InstanceNameInfo Item in CorrespondingInstance.PrecursorInstanceList)
                    {
                        errorList.AddError(new ErrorMissingSelectedPrecursor(Item.Location, Item.Name.Name));
                        Success = false;
                        break;
                    }

                    break;
                }

                Debug.Assert(!Success);
            }

            return(Success);
        }
Esempio n. 15
0
        /// <summary>
        /// Finds the matching nodes of a <see cref="IOldExpression"/>.
        /// </summary>
        /// <param name="node">The agent expression to check.</param>
        /// <param name="errorList">The list of errors found.</param>
        /// <param name="resolvedExpression">The result of the search.</param>
        public static bool ResolveCompilerReferences(IOldExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression)
        {
            resolvedExpression = new ResolvedExpression();

            IClass              EmbeddingClass = node.EmbeddingClass;
            IQualifiedName      Query          = (IQualifiedName)node.Query;
            IList <IIdentifier> ValidPath      = Query.ValidPath.Item;
            IClassType          BaseType       = EmbeddingClass.ResolvedClassType.Item;

            if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType))
            {
                errorList.AddError(new ErrorBooleanTypeMissing(node));
                return(false);
            }

            ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node);

            Debug.Assert(LocalScope != null);

            if (node.EmbeddingBody == null && node.EmbeddingAssertion == null)
            {
                errorList.AddError(new ErrorInvalidOldExpression(node));
                return(false);
            }

            if (!ObjectType.GetQualifiedPathFinalType(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, errorList, out ICompiledFeature FinalFeature, out IDiscrete FinalDiscrete, out ITypeName FinalTypeName, out ICompiledType FinalType, out bool InheritBySideAttribute))
            {
                return(false);
            }

            if (FinalFeature == null)
            {
                errorList.AddError(new ErrorInvalidOldExpression(node));
                return(false);
            }

            ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Query.ValidResultTypePath.Item);

            resolvedExpression.ResolvedFinalFeature = FinalFeature;
            resolvedExpression.ResolvedResult       = new ResultType(FinalTypeName, FinalType, string.Empty);
            resolvedExpression.ResolvedException    = new ResultException();

#if COVERAGE
            Debug.Assert(!node.IsComplex);
#endif

            return(true);
        }
Esempio n. 16
0
        /// <summary>
        /// Validates an import and return the matching library.
        /// </summary>
        /// <param name="libraryTable">Table of valid library names and their sources, updated upon return.</param>
        /// <param name="matchingLibrary">The matching library upon return.</param>
        /// <param name="errorList">List of errors found.</param>
        /// <returns>True if library names are valid.</returns>
        public virtual bool CheckImportConsistency(ISealableDictionary <string, ISealableDictionary <string, ILibrary> > libraryTable, out ILibrary matchingLibrary, IErrorList errorList)
        {
            IErrorStringValidity StringError;
            string      ValidFromIdentifier;
            IIdentifier ImportLibraryIdentifier = (IIdentifier)LibraryIdentifier;
            ISealableDictionary <string, ILibrary> SourceNameTable;

            matchingLibrary = null;

            if (!StringValidation.IsValidIdentifier(ImportLibraryIdentifier, LibraryIdentifier.Text, out string ValidLibraryIdentifier, out StringError))
            {
                errorList.AddError(StringError);
                return(false);
            }

            // Match the library name and source name.
            if (!libraryTable.ContainsKey(ValidLibraryIdentifier))
            {
                errorList.AddError(new ErrorUnknownIdentifier(ImportLibraryIdentifier, ValidLibraryIdentifier));
                return(false);
            }

            SourceNameTable = libraryTable[ValidLibraryIdentifier];

            if (FromIdentifier.IsAssigned)
            {
                IIdentifier ImportFromIdentifier = (IIdentifier)FromIdentifier.Item;

                if (!StringValidation.IsValidIdentifier(ImportFromIdentifier, FromIdentifier.Item.Text, out ValidFromIdentifier, out StringError))
                {
                    errorList.AddError(StringError);
                    return(false);
                }
            }
            else
            {
                ValidFromIdentifier = string.Empty;
            }

            if (!SourceNameTable.ContainsKey(ValidFromIdentifier))
            {
                errorList.AddError(new ErrorUnknownIdentifier(ImportLibraryIdentifier, ValidLibraryIdentifier));
                return(false);
            }

            matchingLibrary = SourceNameTable[ValidFromIdentifier];
            return(true);
        }
Esempio n. 17
0
        private static bool TupleTypeConformToTupleType(ITupleType derivedType, ITupleType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            if (derivedType.EntityDeclarationList.Count < baseType.EntityDeclarationList.Count)
            {
                errorList.AddError(new ErrorFieldMismatchConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            for (int i = 0; i < derivedType.EntityDeclarationList.Count && i < baseType.EntityDeclarationList.Count; i++)
            {
                IEntityDeclaration BaseField    = baseType.EntityDeclarationList[i];
                IEntityDeclaration DerivedField = derivedType.EntityDeclarationList[i];

                Debug.Assert(DerivedField.ValidEntity.IsAssigned);
                Debug.Assert(DerivedField.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
                Debug.Assert(BaseField.ValidEntity.IsAssigned);
                Debug.Assert(BaseField.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);

                Result = TypeConformToBase(DerivedField.ValidEntity.Item.ResolvedEffectiveType.Item, BaseField.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
            }

            return(Result);
        }
        private bool CompareEffectiveFlags(InheritedInstanceInfo importedInstance, IErrorList errorList, IClassType localClassType)
        {
            bool Result = true;

            importedInstance.IsKept         = importedInstance.EffectiveInstance.Item.Instance.IsKept;
            importedInstance.IsDiscontinued = importedInstance.EffectiveInstance.Item.Instance.IsDiscontinued;

            // If the effective instance is a redefine.
            if (importedInstance.EffectiveInstance.Item.Ancestor == localClassType && importedInstance.EffectiveInstance.Item.Instance.Feature.ResolvedAgentType.IsAssigned)
            {
                ICompiledType DescendantFeatureType = importedInstance.EffectiveInstance.Item.Instance.Feature.ResolvedAgentType.Item;

                IList <InstanceNameInfo> InstanceList = importedInstance.PrecursorInstanceList;
                foreach (InstanceNameInfo Item in InstanceList)
                {
                    if (Item == importedInstance.EffectiveInstance.Item)
                    {
                        continue;
                    }

                    ICompiledType AncestorFeatureType = Item.Instance.Feature.ResolvedAgentType.Item;

                    if (!ObjectType.TypeConformToBase(DescendantFeatureType, AncestorFeatureType, errorList, (ISource)importedInstance.EffectiveInstance.Item.Instance.Feature, isConversionAllowed: false))
                    {
                        errorList.AddError(new ErrorInheritanceConflict(Item.Location, Item.Name.Name));
                        Result = false;
                    }
                }
            }

            return(Result);
        }
        private bool IsSingleEffective(ISealableDictionary <IFeatureName, InheritedInstanceInfo> byNameTable, IErrorList errorList)
        {
            bool IsSingle = true;

            foreach (KeyValuePair <IFeatureName, InheritedInstanceInfo> ImportedEntry in byNameTable)
            {
                IFeatureName             ImportedKey      = ImportedEntry.Key;
                InheritedInstanceInfo    ImportedInstance = ImportedEntry.Value;
                IList <InstanceNameInfo> InstanceList     = ImportedInstance.PrecursorInstanceList;

                foreach (InstanceNameInfo Item in InstanceList)
                {
                    if (!Item.Instance.IsForgotten)
                    {
                        if (!ImportedInstance.EffectiveInstance.IsAssigned)
                        {
                            ImportedInstance.EffectiveInstance.Item = Item;
                        }
                        else
                        {
                            errorList.AddError(new ErrorMultipleEffectiveFeature(Item.Location, Item.Name.Name));
                            IsSingle = false;
                            break;
                        }
                    }
                }
            }

            return(IsSingle);
        }
Esempio n. 20
0
        /// <summary>
        /// Checks that a result of a list of overloads conform to a base type.
        /// </summary>
        /// <param name="overloadList">The list of overloads.</param>
        /// <param name="index">Index of the result in the possible results.</param>
        /// <param name="baseType">The base type.</param>
        /// <param name="location">The location where to report errors.</param>
        /// <param name="errorList">The list of errors found.</param>
        public static bool JoinedResultCheck(IList <IQueryOverloadType> overloadList, int index, ICompiledType baseType, ISource location, IErrorList errorList)
        {
            bool Success = true;
            IList <IParameter> SameIndexList = new List <IParameter>();

            foreach (IQueryOverloadType Overload in overloadList)
            {
                ISealableList <IParameter> ResultTable = Overload.ResultTable;
                if (index < ResultTable.Count)
                {
                    SameIndexList.Add(ResultTable[index]);
                }
            }

            for (int i = 0; i < SameIndexList.Count; i++)
            {
                IParameter    CurrentParameter     = SameIndexList[i];
                ICompiledType CurrentParameterType = CurrentParameter.ResolvedParameter.ResolvedEffectiveType.Item;

                if (!ObjectType.TypeConformToBase(CurrentParameterType, baseType, isConversionAllowed: false))
                {
                    errorList.AddError(new ErrorNonConformingType(location));
                    Success = false;
                }
            }

            return(Success);
        }
Esempio n. 21
0
        /// <summary>
        /// Finds the matching nodes of a <see cref="IManifestCharacterExpression"/>.
        /// </summary>
        /// <param name="node">The agent expression to check.</param>
        /// <param name="errorList">The list of errors found.</param>
        /// <param name="resolvedResult">The expression result types upon return.</param>
        /// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
        /// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
        /// <param name="expressionConstant">The expression constant upon return.</param>
        public static bool ResolveCompilerReferences(IManifestCharacterExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant)
        {
            resolvedResult     = null;
            resolvedException  = null;
            constantSourceList = new SealableList <IExpression>();
            expressionConstant = NeutralLanguageConstant.NotConstant;

            IClass EmbeddingClass = node.EmbeddingClass;
            string ValidText      = node.ValidText.Item;

            Debug.Assert(ValidText.Length == 1);
            char ValidChar = ValidText[0];

            if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Character.Guid, node, out ITypeName CharacterTypeName, out ICompiledType CharacterType))
            {
                errorList.AddError(new ErrorCharacterTypeMissing(node));
                return(false);
            }

            resolvedResult = new ResultType(CharacterTypeName, CharacterType, string.Empty);

            resolvedException  = new ResultException();
            expressionConstant = new CharacterLanguageConstant(ValidChar);

#if COVERAGE
            Debug.Assert(!node.IsComplex);
#endif

            return(true);
        }
        private static bool IsWithinGetter(ISource source, IErrorList errorList, out ITypeName resultTypeName, out ICompiledType resultType)
        {
            resultTypeName = null;
            resultType     = null;

            if (source.EmbeddingOverload is IQueryOverload AsQueryOverload)
            {
                return(CheckQueryConsistency(source, AsQueryOverload, errorList, out resultTypeName, out resultType));
            }
            else if (source.EmbeddingFeature is IPropertyFeature AsPropertyFeature)
            {
                if (CheckGetterConsistency(source, AsPropertyFeature.GetterBody, errorList))
                {
                    resultTypeName = AsPropertyFeature.ResolvedEntityTypeName.Item;
                    resultType     = AsPropertyFeature.ResolvedEntityType.Item;
                    return(true);
                }
            }
            else if (source.EmbeddingFeature is IIndexerFeature AsIndexerFeature)
            {
                if (CheckGetterConsistency(source, AsIndexerFeature.GetterBody, errorList))
                {
                    resultTypeName = AsIndexerFeature.ResolvedEntityTypeName.Item;
                    resultType     = AsIndexerFeature.ResolvedEntityType.Item;
                    return(true);
                }
            }
            else
            {
                errorList.AddError(new ErrorUnavailableResult(source));
            }

            return(false);
        }
        /// <summary>
        /// Finds the matching nodes of a <see cref="IManifestNumberExpression"/>.
        /// </summary>
        /// <param name="node">The agent expression to check.</param>
        /// <param name="errorList">The list of errors found.</param>
        /// <param name="resolvedResult">The expression result types upon return.</param>
        /// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
        /// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
        /// <param name="expressionConstant">The constant type upon return.</param>
        public static bool ResolveCompilerReferences(IManifestNumberExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant)
        {
            resolvedResult     = null;
            resolvedException  = null;
            constantSourceList = new SealableList <IExpression>();
            expressionConstant = NeutralLanguageConstant.NotConstant;

            IClass EmbeddingClass = node.EmbeddingClass;
            string NumberText     = node.ValidText.Item;
            ISealableDictionary <ITypeName, ICompiledType> TypeTable = EmbeddingClass.TypeTable;

            if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType))
            {
                errorList.AddError(new ErrorNumberTypeMissing(node));
                return(false);
            }

            resolvedResult    = new ResultType(NumberTypeName, NumberType, string.Empty);
            resolvedException = new ResultException();

            FormattedNumber FormattedNumber = FormattedNumber.Parse(NumberText);

            Debug.Assert(string.IsNullOrEmpty(FormattedNumber.InvalidText));

            expressionConstant = new NumberLanguageConstant(FormattedNumber.Value);

#if COVERAGE
            Debug.Assert(!node.IsComplex);
#endif

            return(true);
        }
Esempio n. 24
0
        private static bool MergeClassTablesWithNewClass(ISealableDictionary <string, IImportedClass> importedClassTable, string className, IImportedClass mergedClassItem, IImport importLocation, BaseNode.ImportType mergedImportType, IErrorList errorList)
        {
            bool Success = true;

            foreach (KeyValuePair <string, IImportedClass> ImportedEntry in importedClassTable)
            {
                IImportedClass ClassItem = ImportedEntry.Value;
                if (ClassItem.Item == mergedClassItem.Item)
                {
                    string OldName = ImportedEntry.Key;
                    errorList.AddError(new ErrorClassAlreadyImported(importLocation, OldName, className));
                    Success = false;
                    break;
                }
            }

            // First time this class is imported, use the merge import type specification and location since they are known.
            if (Success)
            {
                mergedClassItem.SetImportType(mergedImportType);
                mergedClassItem.SetImportLocation(importLocation);

                importedClassTable.Add(className, mergedClassItem);
            }

            return(Success);
        }
Esempio n. 25
0
        private static bool PropertyTypeConformToPropertyType(IPropertyType derivedType, IPropertyType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            Debug.Assert(derivedType.ResolvedBaseType.IsAssigned);
            Debug.Assert(baseType.ResolvedBaseType.IsAssigned);

            Result &= TypeConformToBase(derivedType.ResolvedBaseType.Item, baseType.ResolvedBaseType.Item, errorList, sourceLocation, isConversionAllowed: false);

            if ((baseType.PropertyKind == BaseNode.UtilityType.ReadOnly && derivedType.PropertyKind == BaseNode.UtilityType.WriteOnly) ||
                (baseType.PropertyKind == BaseNode.UtilityType.WriteOnly && derivedType.PropertyKind == BaseNode.UtilityType.ReadOnly) ||
                (baseType.PropertyKind == BaseNode.UtilityType.ReadWrite && derivedType.PropertyKind != BaseNode.UtilityType.ReadWrite))
            {
                errorList.AddError(new ErrorGetterSetterConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            Debug.Assert(derivedType.ResolvedEntityType.IsAssigned);
            Debug.Assert(baseType.ResolvedEntityType.IsAssigned);

            /*
             * if (!TypesHaveIdenticalSignature(derivedType.ResolvedEntityType.Item, baseType.ResolvedEntityType.Item))
             * {
             *  //errorList.Add(new ConformanceError(sourceLocation));
             *  return false;
             * }
             */

            Result &= TypeConformToBase(derivedType.ResolvedEntityType.Item, baseType.ResolvedEntityType.Item, errorList, sourceLocation, isConversionAllowed: false);
            Result &= ExceptionListConformToBase(derivedType.GetExceptionIdentifierList, baseType.GetExceptionIdentifierList, errorList, sourceLocation);
            Result &= ExceptionListConformToBase(derivedType.SetExceptionIdentifierList, baseType.SetExceptionIdentifierList, errorList, sourceLocation);

            return(Result);
        }
Esempio n. 26
0
        /// <summary>
        /// Checks that a command overload conforms to another.
        /// </summary>
        /// <param name="derivedType">The derived type.</param>
        /// <param name="baseType">The base type.</param>
        /// <param name="errorList">The list of errors found.</param>
        /// <param name="sourceLocation">The location for reporting errors.</param>
        public static bool CommandOverloadConformToBase(ICommandOverloadType derivedType, ICommandOverloadType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            if (baseType.ParameterList.Count != derivedType.ParameterList.Count || baseType.ParameterEnd != derivedType.ParameterEnd)
            {
                errorList.AddError(new ErrorParameterMismatchConformance(sourceLocation, derivedType, baseType));
                Result = false;
            }

            for (int i = 0; i < baseType.ParameterList.Count && i < derivedType.ParameterList.Count; i++)
            {
                IEntityDeclaration BaseParameter    = baseType.ParameterList[i];
                IEntityDeclaration DerivedParameter = derivedType.ParameterList[i];

                Debug.Assert(DerivedParameter.ValidEntity.IsAssigned);
                Debug.Assert(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);
                Debug.Assert(BaseParameter.ValidEntity.IsAssigned);
                Debug.Assert(BaseParameter.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);

                Result &= TypeConformToBase(DerivedParameter.ValidEntity.Item.ResolvedEffectiveType.Item, BaseParameter.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
            }

            Result &= ExceptionListConformToBase(derivedType.ExceptionIdentifierList, baseType.ExceptionIdentifierList, errorList, sourceLocation);

            return(Result);
        }
Esempio n. 27
0
        /// <summary>
        /// Finds the matching nodes of a <see cref="IResultOfExpression"/>.
        /// </summary>
        /// <param name="node">The agent expression to check.</param>
        /// <param name="errorList">The list of errors found.</param>
        /// <param name="resolvedResult">The expression result types upon return.</param>
        /// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
        /// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
        /// <param name="expressionConstant">The expression constant upon return.</param>
        public static bool ResolveCompilerReferences(IResultOfExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant)
        {
            resolvedResult     = null;
            resolvedException  = null;
            constantSourceList = new SealableList <IExpression>();
            expressionConstant = NeutralLanguageConstant.NotConstant;

            IExpression Source = (IExpression)node.Source;
            IResultType ResolvedSourceResult = Source.ResolvedResult.Item;
            int         ResultNameIndex      = ResolvedSourceResult.ResultNameIndex;

            if (ResultNameIndex < 0)
            {
                errorList.AddError(new ErrorInvalidExpression(node));
                return(false);
            }

            Debug.Assert(ResolvedSourceResult.Preferred != null);
            resolvedResult = new ResultType(ResolvedSourceResult.Preferred);

            constantSourceList.Add(Source);

            ResultException.Propagate(Source.ResolvedException, out resolvedException);

#if COVERAGE
            Debug.Assert(node.IsComplex);
#endif

            return(true);
        }
Esempio n. 28
0
        private static bool QueryOverloadHasPropertyConformingBase(IQueryOverloadType derivedOverload, IPropertyType baseType, IErrorList errorList, ISource sourceLocation)
        {
            bool Result = true;

            if (derivedOverload.ParameterList.Count > 0 || derivedOverload.ResultList.Count != 1 || derivedOverload.ParameterEnd != BaseNode.ParameterEndStatus.Closed)
            {
                errorList.AddError(new ErrorOverloadParameterMismatchConformance(sourceLocation, derivedOverload, baseType));
                Result = false;
            }

            if (derivedOverload.ResultList.Count == 1)
            {
                IEntityDeclaration OverloadResult = derivedOverload.ResultList[0];

                Debug.Assert(baseType.ResolvedEntityType.IsAssigned);
                Debug.Assert(OverloadResult.ValidEntity.IsAssigned);
                Debug.Assert(OverloadResult.ValidEntity.Item.ResolvedEffectiveType.IsAssigned);

                Result &= TypeConformToBase(baseType.ResolvedEntityType.Item, OverloadResult.ValidEntity.Item.ResolvedEffectiveType.Item, errorList, sourceLocation, isConversionAllowed: false);
            }

            Result &= ExceptionListConformToBase(derivedOverload.ExceptionIdentifierList, baseType.GetExceptionIdentifierList, errorList, sourceLocation);

            return(Result);
        }
        private static bool ResolveCallClass(IPrecursorExpression node, IFeatureInstance selectedPrecursor, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList)
        {
            selectedParameterList = null;
            selectedResultList    = null;
            resolvedArgumentList  = null;

            IList <IArgument> ArgumentList = node.ArgumentList;

            if (ArgumentList.Count > 0)
            {
                errorList.AddError(new ErrorInvalidExpression(node));
                return(false);
            }
            else
            {
                ICompiledFeature OperatorFeature  = selectedPrecursor.Feature;
                ITypeName        OperatorTypeName = OperatorFeature.ResolvedEffectiveTypeName.Item;
                ICompiledType    OperatorType     = OperatorFeature.ResolvedEffectiveType.Item;
                IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >();

                resolvedExpression.ResolvedResult    = new ResultType(OperatorTypeName, OperatorType, string.Empty);
                resolvedExpression.ResolvedException = new ResultException();
                selectedParameterList = new SealableList <IParameter>();
                selectedResultList    = new SealableList <IParameter>();
                resolvedArgumentList  = new List <IExpressionType>();
            }

            return(true);
        }
Esempio n. 30
0
        private static bool GetArgumentPassingStyle(IList <IArgument> argumentList, out TypeArgumentStyles argumentStyle, IErrorList errorList)
        {
            argumentStyle = TypeArgumentStyles.None;

            foreach (IArgument Argument in argumentList)
            {
                bool IsHandled = false;

                switch (Argument)
                {
                case IPositionalArgument AsPositionalArgument:
                    if (argumentStyle == TypeArgumentStyles.None)
                    {
                        argumentStyle = TypeArgumentStyles.Positional;
                    }
                    else if (argumentStyle == TypeArgumentStyles.Assignment)
                    {
                        errorList.AddError(new ErrorArgumentMixed(AsPositionalArgument));
                        return(false);
                    }

                    IsHandled = true;
                    break;

                case IAssignmentArgument AsAssignmentArgument:
                    if (argumentStyle == TypeArgumentStyles.None)
                    {
                        argumentStyle = TypeArgumentStyles.Assignment;
                    }
                    else if (argumentStyle == TypeArgumentStyles.Positional)
                    {
                        errorList.AddError(new ErrorArgumentMixed(AsAssignmentArgument));
                        return(false);
                    }

                    IsHandled = true;
                    break;
                }

                Debug.Assert(IsHandled);
            }

            return(true);
        }