protected Context() { // Context tables _functions = new RoutinesTable(RoutinesAppContext.NameToIndex, RoutinesAppContext.AppRoutines, RoutinesAppContext.ContextRoutinesCounter, FunctionRedeclared); _types = new TypesTable(TypesAppContext.NameToIndex, TypesAppContext.AppTypes, TypesAppContext.ContextTypesCounter, TypeRedeclared); _statics = new object[StaticIndexes.StaticsCount]; }
public void TranslateSchema(Schema pimSchema, bool translateAsOldVersion = false) { List <PIMBridgeClass> classToProcess = new List <PIMBridgeClass>(); //vytvoreni prazdnych trid //musi predchazet propertam a associacim, aby se neodkazovalo na neexistujici typy // JM: usporadani trid tak, aby predkove byli zalozeni pred potomky List <PIMClass> pimClassesHierarchy = ModelIterator.GetPIMClassesInheritanceBFS((PIMSchema)pimSchema).ToList(); foreach (PIMClass pimClass in pimClassesHierarchy) { // JM: parent - predek v PIM modelu PIMBridgeClass parent = pimClass.GeneralizationAsSpecific != null ? PIMClasses[pimClass.GeneralizationAsSpecific.General] : null; string nameOverride = translateAsOldVersion ? pimClass.Name + @"_old" : null; PIMBridgeClass newClass = new PIMBridgeClass(TypesTable, TypesTable.Library.RootNamespace, pimClass, parent, nameOverride); // tt.Library.RootNamespace.NestedClassifier.Add(newClass); TypesTable.RegisterType(newClass); classToProcess.Add(newClass); //Hack newClass.Tag = pimClass; //Registred to find PIMClasses.Add(pimClass, newClass); } //Translates classes members classToProcess.ForEach(cl => cl.TranslateMembers()); }
public void NamespaceTest() { TypesTable typeTable = new TypesTable(); StandardLibraryCreator sl = new StandardLibraryCreator(); sl.CreateStandardLibrary(typeTable); Namespace basic = typeTable.Library.RootNamespace; Namespace subNamespace = new Namespace("subNamespace", basic); Classifier integerType = typeTable.Library.Integer; Classifier realType = typeTable.Library.Real; Classifier anyType = typeTable.Library.Any; Class baseClass = new Class(typeTable, subNamespace, "Base"); baseClass.Properties.Add(new Property("Name", PropertyType.One, integerType)); baseClass.Operations.Add(new Operation("Work", true, integerType, new Parameter[] { })); Class A = new Class(typeTable, basic, "A"); Class B = new Class(typeTable, basic, "B"); A.SuperClass.Add(baseClass); B.SuperClass.Add(baseClass); typeTable.RegisterType(baseClass); typeTable.RegisterType(A); typeTable.RegisterType(B); Assert.IsTrue(B.ConformsTo(baseClass)); Assert.IsFalse(B.ConformsTo(A)); Assert.AreEqual(baseClass.ToString(), "::subNamespace::Base"); }
public void CollectionTest() { TypesTable typesTable = new TypesTable(); StandardLibraryCreator sl = new StandardLibraryCreator(); sl.CreateStandardLibrary(typesTable); Classifier integerType = typesTable.Library.Integer; Classifier realType = typesTable.Library.Real; Classifier anyType = typesTable.Library.Any; CollectionType bagInteger = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, integerType); CollectionType bagReal = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, realType); CollectionType setType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Set, integerType); CollectionType seqType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Sequence, integerType);; CollectionType ordType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.OrderedSet, integerType); CollectionType collInteger = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Collection, integerType); Assert.IsTrue(bagInteger.ConformsTo(bagReal)); Assert.IsTrue(bagInteger.ConformsTo(collInteger)); Assert.IsFalse(bagReal.ConformsTo(collInteger)); Assert.IsFalse(bagInteger.ConformsTo(seqType)); Assert.IsFalse(bagInteger.ConformsTo(setType)); Assert.IsFalse(bagInteger.ConformsTo(ordType)); Assert.IsFalse(seqType.ConformsTo(bagInteger)); Assert.IsFalse(seqType.ConformsTo(setType)); Assert.IsFalse(seqType.ConformsTo(ordType)); Assert.IsFalse(ordType.ConformsTo(bagInteger)); Assert.IsFalse(ordType.ConformsTo(setType)); Assert.IsFalse(ordType.ConformsTo(seqType)); Assert.IsFalse(setType.ConformsTo(bagInteger)); Assert.IsFalse(setType.ConformsTo(ordType)); Assert.IsFalse(setType.ConformsTo(seqType)); Assert.IsTrue(bagInteger.CollectionKind == Exolutio.Model.OCL.CollectionKind.Bag); Assert.IsTrue(collInteger.CollectionKind == Exolutio.Model.OCL.CollectionKind.Collection); Assert.IsTrue(setType.CollectionKind == Exolutio.Model.OCL.CollectionKind.Set); Assert.IsTrue(seqType.CollectionKind == Exolutio.Model.OCL.CollectionKind.Sequence); Assert.IsTrue(ordType.CollectionKind == Exolutio.Model.OCL.CollectionKind.OrderedSet); Assert.AreEqual(bagInteger.Name, "Bag(" + integerType.QualifiedName + ")"); Assert.AreEqual(collInteger.Name, "Collection(" + integerType.QualifiedName + ")"); Assert.AreEqual(setType.Name, "Set(" + integerType.QualifiedName + ")"); Assert.AreEqual(ordType.Name, "OrderedSet(" + integerType.QualifiedName + ")"); Assert.AreEqual(seqType.Name, "Sequence(" + integerType.QualifiedName + ")"); Assert.IsTrue(bagInteger == typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, integerType)); Assert.IsFalse(bagInteger == null); Assert.IsFalse(bagInteger == bagReal); Assert.IsFalse(bagInteger.Equals(null)); Assert.IsTrue(bagInteger.ConformsTo(anyType)); }
public void StringTest() { TryCompile(@"context Tournament inv: 'a'='a'"); TypesTable tt = new TypesTable(); StandardLibraryCreator sLC = new StandardLibraryCreator(); sLC.CreateStandardLibrary(tt); Compiler compiler = new Compiler(); Exolutio.Model.OCL.Environment env = new NamespaceEnvironment(tt.Library.RootNamespace); testString(compiler, tt, env, "''", ""); testString(compiler, tt, env, "'a'", "a"); testString(compiler, tt, env, "'aa'", "aa"); testString(compiler, tt, env, "'\\b'", "\b"); testString(compiler, tt, env, "'\\t'", "\t"); testString(compiler, tt, env, "'\\n'", "\n"); testString(compiler, tt, env, "'\\f'", "\f"); testString(compiler, tt, env, "'\\r'", "\r"); testString(compiler, tt, env, "'\\\"'", "\""); testString(compiler, tt, env, "'\\''", "'"); testString(compiler, tt, env, "'\\x27'", "\x27"); testString(compiler, tt, env, "'\\u1127'", "\x1127"); testString(compiler, tt, env, @"'\\t'", @"\t"); testString(compiler, tt, env, @"'\\\t'", "\\\t"); testString(compiler, tt, env, @"'\\\\t'", "\\\\t"); testString(compiler, tt, env, @"'\\\\\t'", "\\\\\t"); testString(compiler, tt, env, @"'\\\\\\t'", "\\\\\\t"); }
static void AddScriptReference(Assembly assembly) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } // remember the assembly for class map: s_assClassMap.AddPhpAssemblyNoLock(assembly); // reflect the module for imported symbols: var module = assembly.ManifestModule; // PhpPackageReferenceAttribute foreach (var r in module.GetCustomAttributes <PhpPackageReferenceAttribute>()) { Context.AddScriptReference(r.ScriptType); } // ImportPhpTypeAttribute foreach (var t in module.GetCustomAttributes <ImportPhpTypeAttribute>()) { TypesTable.DeclareAppType(PhpTypeInfoExtension.GetPhpTypeInfo(t.ImportedType)); } // ImportPhpFunctionsAttribute foreach (var t in module.GetCustomAttributes <ImportPhpFunctionsAttribute>()) { // TODO: remember the container, do not reflect repetitiously foreach (var m in t.ContainerType.GetMethods()) { if (m.IsPublic && m.IsStatic && !m.IsPhpHidden()) { RoutinesTable.DeclareAppRoutine(m.Name, m); } } } // ImportPhpConstantsAttribute foreach (var t in module.GetCustomAttributes <ImportPhpConstantsAttribute>()) { // TODO: remember the container, do not reflect repetitiously foreach (var m in t.ContainerType.GetMembers(BindingFlags.Static | BindingFlags.Public)) { if (m is FieldInfo fi && !fi.IsPhpHidden()) { Debug.Assert(fi.IsStatic && fi.IsPublic); if (fi.IsInitOnly || fi.IsLiteral) { ConstsMap.DefineAppConstant(fi.Name, PhpValue.FromClr(fi.GetValue(null))); } else { ConstsMap.DefineAppConstant(fi.Name, new Func <PhpValue>(() => PhpValue.FromClr(fi.GetValue(null)))); } }
TupleType CreateTupleType(IToken rootToken, List <VariableDeclarationBag> variables) { if (TestNull(rootToken, variables)) { TupleType tupleType = new TupleType(TypesTable, new List <Property>()); TypesTable.RegisterType(tupleType); return(tupleType); } Dictionary <string, Property> tupleParts = new Dictionary <string, Property>(); foreach (var variable in variables) { if (tupleParts.Keys.Contains(variable.Name)) // Kontrola nad ramec specifikace { Errors.AddError(new CodeErrorItem(String.Format(CompilerErrors.OCLAst_CreateTupleLiteral_Name_repeated_1, variable.Name), rootToken, rootToken)); continue; } Classifier propertyType = variable.Type; if (variable.Type == null) { propertyType = Library.Invalid; } tupleParts.Add(variable.Name, new Property(variable.Name, PropertyType.One, propertyType)); } TupleType tuple = new TupleType(TypesTable, tupleParts.Values); TypesTable.RegisterType(tuple); return(tuple); }
protected Context() { // tables _functions = new RoutinesTable(); _types = new TypesTable(); _statics = new object[StaticIndexes.StaticsCount]; _constants = ConstsMap.Create(this); _scripts = ScriptsMap.Create(); }
protected Context() { // Context tables _functions = new RoutinesTable(FunctionRedeclared); _types = new TypesTable(TypeRedeclared); _statics = new object[StaticIndexes.StaticsCount]; // this.DefineConstant("PHP_SAPI", (PhpValue)this.ServerApi, ignorecase: false); }
protected Context() { _functions = new RoutinesTable(RoutinesAppContext.NameToIndex, RoutinesAppContext.AppRoutines, RoutinesAppContext.ContextRoutinesCounter, FunctionRedeclared); _types = new TypesTable(TypesAppContext.NameToIndex, TypesAppContext.AppTypes, TypesAppContext.ContextTypesCounter, TypeRedeclared); _statics = new object[StaticIndexes.StaticsCount]; _globals = new PhpArray(); _server = new PhpArray(); // TODO: virtual initialization method, reuse server static information with request context // TODO: InitGlobalVariables(); //_globals.SetItemAlias(new IntStringKey("GLOBALS"), new PhpAlias(PhpValue.Create(_globals))); }
AST.TupleLiteralExp CreateTupleLiteral(IToken rootToken, List <VariableDeclarationBag> vars) { if (TestNull(rootToken, vars)) { TupleType tupleTypeErr = new TupleType(TypesTable, new List <Property>()); TypesTable.RegisterType(tupleTypeErr); return(new AST.TupleLiteralExp(new Dictionary <string, AST.TupleLiteralPart>(), tupleTypeErr) .SetCodeSource(new CodeSource(rootToken))); } Dictionary <string, AST.TupleLiteralPart> parts = new Dictionary <string, AST.TupleLiteralPart>(); List <Property> tupleParts = new List <Property>(); foreach (var var in vars) { if (parts.ContainsKey(var.Name)) { Errors.AddError(new CodeErrorItem(String.Format(CompilerErrors.OCLAst_CreateTupleLiteral_Name_repeated_1, var.Name), rootToken, rootToken)); continue; } AST.OclExpression expr = var.Expression; if (var.Expression == null) { expr = new AST.ErrorExp(Library.Invalid); } Classifier type = var.Type; if (type == null) { type = expr.Type; } if (expr.Type.ConformsTo(type) == false) { Errors.AddError(new ErrorItem(CompilerErrors.OCLAst_CreateTupleLiteral_Type_does_not_comform_to_declared_type)); } //hodnota var newProterty = new Property(var.Name, PropertyType.One, type); var newPart = new AST.TupleLiteralPart(newProterty, expr); parts.Add(var.Name, newPart); //typ tupleParts.Add(newProterty); } TupleType tupleType = new TupleType(TypesTable, tupleParts); TypesTable.RegisterType(tupleType); return(new AST.TupleLiteralExp(parts, tupleType) .SetCodeSource(new CodeSource(rootToken)));; }
/// <summary> /// Initializes instance of context. /// </summary> /// <param name="services">Service provider. Can be <c>null</c> reference to use implicit services.</param> protected Context(IServiceProvider services) { _services = services; // tables _functions = new RoutinesTable(); _types = new TypesTable(); _statics = Array.Empty <object>(); _constants = ConstsMap.Create(this); _scripts = ScriptsMap.Create(); }
public void TupleTest() { TypesTable typesTalbe = new TypesTable(); StandardLibraryCreator sl = new StandardLibraryCreator(); sl.CreateStandardLibrary(typesTalbe); Classifier integerType = typesTalbe.Library.Integer; Classifier realType = typesTalbe.Library.Real; Classifier anyType = typesTalbe.Library.Any; typesTalbe.RegisterType(integerType); typesTalbe.RegisterType(realType); typesTalbe.RegisterType(anyType); List <Property> tupleParts1 = new List <Property>(); tupleParts1.Add(new Property("prop1", PropertyType.One, integerType)); tupleParts1.Add(new Property("prop2", PropertyType.One, integerType)); TupleType tuple = new TupleType(typesTalbe, tupleParts1); typesTalbe.RegisterType(tuple); List <Property> tupleParts2 = new List <Property>(); tupleParts2.Add(new Property("prop1", PropertyType.One, realType)); tupleParts2.Add(new Property("prop2", PropertyType.One, integerType)); TupleType tuple2 = new TupleType(typesTalbe, tupleParts2); typesTalbe.RegisterType(tuple2); Assert.IsTrue(tuple.ConformsTo(tuple2)); Assert.IsFalse(tuple2.ConformsTo(tuple)); List <Property> tupleParts3 = new List <Property>(); tupleParts3.Add(new Property("prop1", PropertyType.One, realType)); tupleParts3.Add(new Property("prop2", PropertyType.One, integerType)); tupleParts3.Add(new Property("prop3", PropertyType.One, anyType)); TupleType tuple3 = new TupleType(typesTalbe, tupleParts3); typesTalbe.RegisterType(tuple3); Assert.IsFalse(tuple.ConformsTo(tuple3)); Assert.IsTrue(tuple.ConformsTo(anyType)); Assert.IsTrue(tuple["prop1"].Type == integerType); Assert.AreEqual(tuple.Name, "Tuple(prop1:Integer,prop2:Integer)"); }
public void SimpleExpression() { TypesTable tt = new TypesTable(); StandardLibraryCreator sLC = new StandardLibraryCreator(); sLC.CreateStandardLibrary(tt); Compiler compiler = new Compiler(); Exolutio.Model.OCL.Environment env = new NamespaceEnvironment(tt.Library.RootNamespace); var res = compiler.CompileStandAloneExpression("1=1", tt, env); Assert.IsFalse(res.Errors.HasError); Assert.AreEqual(typeof(OperationCallExp), res.Expression.GetType()); }
public void PrimitiveTypeConformsToTest() { TypesTable typesTalbe = new TypesTable(); StandardLibraryCreator sl = new StandardLibraryCreator(); sl.CreateStandardLibrary(typesTalbe); Classifier integerType = typesTalbe.Library.Integer; Classifier realType = typesTalbe.Library.Real; Classifier unlimnaturalType = typesTalbe.Library.UnlimitedNatural; typesTalbe.RegisterType(integerType); typesTalbe.RegisterType(realType); typesTalbe.RegisterType(unlimnaturalType); Assert.IsTrue(integerType.ConformsTo(realType)); Assert.IsFalse(realType.ConformsTo(integerType)); Assert.IsTrue(unlimnaturalType.ConformsTo(integerType)); Assert.IsFalse(integerType.ConformsTo(unlimnaturalType)); Assert.IsTrue(unlimnaturalType.ConformsTo(realType)); //Pridat dalsi }
void testString(Compiler compiler, TypesTable tt, Exolutio.Model.OCL.Environment env, string oclString,string expected) { var res = compiler.CompileStandAloneExpression(oclString, tt, env); Assert.IsFalse(res.Errors.HasError); Assert.IsTrue(res.Expression is StringLiteralExp); Assert.AreEqual(expected, (res.Expression as StringLiteralExp).Value); }
/// <summary> /// Reflects given assembly for PeachPie compiler specifics - compiled scripts, references to other assemblies, declared functions and classes. /// Scripts and declarations are loaded into application context (static). /// </summary> /// <param name="assembly">PeachPie compiler generated assembly.</param> /// <remarks>Not thread safe.</remarks> public static void AddScriptReference(Assembly assembly) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } if (assembly.GetType(ScriptInfo.ScriptTypeName) == null || !TryAddAssembly(assembly)) { // nothing to reflect return; } // reflect the module for imported symbols: var module = assembly.ManifestModule; // PhpPackageReferenceAttribute foreach (var r in module.GetCustomAttributes <PhpPackageReferenceAttribute>()) { AddPhpPackageReference(r.ScriptType); } // ImportPhpTypeAttribute foreach (var t in module.GetCustomAttributes <ImportPhpTypeAttribute>()) { TypesTable.DeclareAppType(PhpTypeInfoExtension.GetPhpTypeInfo(t.ImportedType)); } // ImportPhpFunctionsAttribute foreach (var t in module.GetCustomAttributes <ImportPhpFunctionsAttribute>()) { if (ExtensionsAppContext.ExtensionsTable.VisitFunctionsContainer(t.ContainerType, out var attr)) { foreach (var m in t.ContainerType.GetMethods()) { if (m.IsPublic && m.IsStatic && !m.IsSpecialName && !m.IsPhpHidden()) { ExtensionsAppContext.ExtensionsTable.AddRoutine(attr, RoutinesTable.DeclareAppRoutine(m.Name, m)); } } } } // ImportPhpConstantsAttribute foreach (var t in module.GetCustomAttributes <ImportPhpConstantsAttribute>()) { if (!s_processedConstantsContainers.Add(t.ContainerType)) { // already visited before continue; } // var extensionName = t.ContainerType.GetCustomAttribute <PhpExtensionAttribute>(false)?.FirstExtensionOrDefault; // reflect constants defined in the container foreach (var m in t.ContainerType.GetMembers(BindingFlags.Static | BindingFlags.Public)) { if (m is FieldInfo fi && !fi.IsPhpHidden()) { Debug.Assert(fi.IsStatic && fi.IsPublic); if (fi.IsInitOnly || fi.IsLiteral) { // constant ConstsMap.DefineAppConstant(fi.Name, PhpValue.FromClr(fi.GetValue(null)), false, extensionName); } else { // static field ConstsMap.DefineAppConstant(fi.Name, new Func <PhpValue>(() => PhpValue.FromClr(fi.GetValue(null))), false, extensionName); } }
public void CommonSuperTypeTest() { TypesTable typesTable = new TypesTable(); StandardLibraryCreator sl = new StandardLibraryCreator(); sl.CreateStandardLibrary(typesTable); Classifier integerType = typesTable.Library.Integer; Classifier realType = typesTable.Library.Real; Classifier anyType = typesTable.Library.Any; Classifier unlimitedType = typesTable.Library.UnlimitedNatural; Classifier stringType = typesTable.Library.String; Assert.AreEqual(integerType.CommonSuperType(realType), realType); //real,integer -> real Assert.AreEqual(realType.CommonSuperType(realType), realType); //real,real -> real Assert.AreEqual(realType.CommonSuperType(integerType), realType); //integer,real -> real Assert.AreEqual(unlimitedType.CommonSuperType(realType), realType); //unlimited,real -> real Assert.AreEqual(integerType.CommonSuperType(unlimitedType), integerType); //integer,unlimited -> integer Assert.AreEqual(stringType.CommonSuperType(integerType), anyType); // string,integer -> anytype //Collection BagType bagIntegerType = (BagType)typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, integerType); BagType bagRealType = (BagType)typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, realType); SetType setType = (SetType)typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Set, integerType); SequenceType seqType = (SequenceType)typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Sequence, integerType); OrderedSetType ordType = (OrderedSetType)typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.OrderedSet, integerType); CollectionType collIntegerType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Collection, integerType); CollectionType collRealType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Collection, realType);; Assert.AreEqual(setType.CommonSuperType(setType), setType); //set(integer),set(integer) -> set(integer) Assert.AreEqual(setType.CommonSuperType(ordType), collIntegerType); //set(integer),ord(integer) -> coll(integer) Assert.AreEqual(setType.CommonSuperType(collIntegerType), collIntegerType); //set(integer),coll(Integer) -> coll(integer) Assert.AreEqual(collIntegerType.CommonSuperType(collIntegerType), collIntegerType); //coll(integer),coll(integer) -> coll(integer) Assert.AreEqual(collIntegerType.CommonSuperType(bagIntegerType), collIntegerType); //coll(integer),bag(integer) -> coll(integer) Assert.AreEqual(collIntegerType.CommonSuperType(bagRealType), collRealType); // coll(Integer),bag(real) -> coll(real) Assert.AreEqual(setType.CommonSuperType(bagRealType), collRealType); // set(integer),bag(real) ->col(real) Assert.AreEqual(ordType.CommonSuperType(ordType), ordType); // ord(integer),ord(integer) -> ord(integer) Assert.AreEqual(seqType.CommonSuperType(seqType), seqType); // seq(integer),seq(integer) -> seq(integer) Assert.AreEqual(setType.CommonSuperType(realType), anyType); //set(integer),real -> any //void test Classifier voidType = typesTable.Library.Void; Assert.AreEqual(voidType.CommonSuperType(integerType), integerType); Assert.AreEqual(realType.CommonSuperType(voidType), realType); Assert.AreEqual(voidType.CommonSuperType(seqType), seqType); Assert.AreEqual(collIntegerType.CommonSuperType(voidType), collIntegerType); Assert.AreEqual(voidType.CommonSuperType(anyType), anyType); //any test Assert.AreEqual(integerType.CommonSuperType(anyType), anyType); Assert.AreEqual(anyType.CommonSuperType(stringType), anyType); Assert.AreEqual(anyType.CommonSuperType(setType), anyType); Assert.AreEqual(setType.CommonSuperType(anyType), anyType); //tuple test List <Property> tupleParts1 = new List <Property>(); tupleParts1.Add(new Property("prop1", PropertyType.Many, integerType)); tupleParts1.Add(new Property("prop2", PropertyType.Many, integerType)); tupleParts1.Add(new Property("prop3", PropertyType.Many, realType)); TupleType tuple1 = new TupleType(typesTable, tupleParts1); typesTable.RegisterType(tuple1); List <Property> tupleParts2 = new List <Property>(); tupleParts2.Add(new Property("prop1", PropertyType.Many, integerType)); tupleParts2.Add(new Property("prop4", PropertyType.Many, integerType)); tupleParts2.Add(new Property("prop3", PropertyType.One, anyType)); TupleType tuple2 = new TupleType(typesTable, tupleParts2); typesTable.RegisterType(tuple2); TupleType tupleCommon = (TupleType)tuple1.CommonSuperType(tuple2); Assert.AreEqual(tupleCommon.TupleParts.Count, 2); Assert.AreEqual(tupleCommon["prop1"].PropertyType, tuple1["prop1"].PropertyType); Assert.AreEqual(tupleCommon["prop1"].Type, tuple1["prop1"].Type); Assert.AreEqual(tupleCommon["prop3"].PropertyType, tuple1["prop3"].PropertyType); Assert.AreEqual(tupleCommon["prop3"].Type, tuple2["prop3"].Type); Assert.AreEqual(tuple1.CommonSuperType(voidType), tuple1); Assert.AreEqual(tuple1.CommonSuperType(anyType), anyType); Assert.AreEqual(voidType.CommonSuperType(tuple1), tuple1); Assert.AreEqual(anyType.CommonSuperType(tuple1), anyType); Assert.AreEqual(tuple2.CommonSuperType(integerType), anyType); Assert.AreEqual(realType.CommonSuperType(tuple2), anyType); }
/// <summary> /// Reflects given assembly for PeachPie compiler specifics - compiled scripts, references to other assemblies, declared functions and classes. /// Scripts and declarations are loaded into application context (static). /// </summary> /// <param name="assembly">PeachPie compiler generated assembly.</param> /// <remarks>Not thread safe.</remarks> public static void AddScriptReference(Assembly assembly) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } if (assembly.GetType(ScriptInfo.ScriptTypeName) == null || !s_processedAssemblies.Add(assembly)) { // nothing to reflect return; } s_processedAssembliesArr = ArrayUtils.AppendRange(assembly, s_processedAssembliesArr); // TODO: ImmutableArray<T> // remember the assembly for class map: s_assClassMap.AddPhpAssemblyNoLock(assembly); // reflect the module for imported symbols: var module = assembly.ManifestModule; // PhpPackageReferenceAttribute foreach (var r in module.GetCustomAttributes <PhpPackageReferenceAttribute>()) { if (r.ScriptType != null) // always true { AddScriptReference(r.ScriptType.Assembly); } } // ImportPhpTypeAttribute foreach (var t in module.GetCustomAttributes <ImportPhpTypeAttribute>()) { TypesTable.DeclareAppType(PhpTypeInfoExtension.GetPhpTypeInfo(t.ImportedType)); } // ImportPhpFunctionsAttribute foreach (var t in module.GetCustomAttributes <ImportPhpFunctionsAttribute>()) { if (ExtensionsAppContext.ExtensionsTable.VisitFunctionsContainer(t.ContainerType, out var attr)) { foreach (var m in t.ContainerType.GetMethods()) { if (m.IsPublic && m.IsStatic && !m.IsPhpHidden()) { ExtensionsAppContext.ExtensionsTable.AddRoutine(attr, RoutinesTable.DeclareAppRoutine(m.Name, m)); } } } } // ImportPhpConstantsAttribute foreach (var t in module.GetCustomAttributes <ImportPhpConstantsAttribute>()) { if (!s_processedConstantsContainers.Add(t.ContainerType)) { // already visited before continue; } // reflect constants defined in the container foreach (var m in t.ContainerType.GetMembers(BindingFlags.Static | BindingFlags.Public)) { if (m is FieldInfo fi && !fi.IsPhpHidden()) { Debug.Assert(fi.IsStatic && fi.IsPublic); if (fi.IsInitOnly || fi.IsLiteral) { ConstsMap.DefineAppConstant(fi.Name, PhpValue.FromClr(fi.GetValue(null))); } else { ConstsMap.DefineAppConstant(fi.Name, new Func <PhpValue>(() => PhpValue.FromClr(fi.GetValue(null)))); } }
public void ReflexivityConformsToTest() { TypesTable typesTable = new TypesTable(); StandardLibraryCreator sl = new StandardLibraryCreator(); sl.CreateStandardLibrary(typesTable); Classifier integerType = typesTable.Library.Integer; Assert.IsTrue(integerType.ConformsTo(integerType)); Classifier realType = typesTable.Library.Real; Assert.IsTrue(realType.ConformsTo(realType)); CollectionType collType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, integerType); CollectionType collType2 = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, integerType); typesTable.RegisterType(collType); typesTable.RegisterType(collType2); Assert.IsTrue(collType.ConformsTo(collType)); Assert.IsTrue(collType.ConformsTo(collType2)); List <Property> tupleParts1 = new List <Property>(); tupleParts1.Add(new Property("ahoj", PropertyType.One, integerType)); TupleType tuple = new TupleType(typesTable, tupleParts1); typesTable.RegisterType(tuple); List <Property> tupleParts2 = new List <Property>(); tupleParts2.Add(new Property("ahoj", PropertyType.One, integerType)); TupleType tuple2 = new TupleType(typesTable, tupleParts2); typesTable.RegisterType(tuple2); Assert.IsTrue(tuple.ConformsTo(tuple)); Assert.IsTrue(tuple.ConformsTo(tuple2)); CollectionType bagType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, integerType); CollectionType bagType2 = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Bag, integerType); Assert.IsTrue(bagType.ConformsTo(bagType)); Assert.IsTrue(bagType.ConformsTo(bagType2)); CollectionType setType = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Set, integerType); CollectionType setType2 = typesTable.Library.CreateCollection(Exolutio.Model.OCL.CollectionKind.Set, integerType); Assert.IsTrue(setType.ConformsTo(setType)); Assert.IsTrue(setType.ConformsTo(setType2)); Classifier voidType = typesTable.Library.Void; typesTable.RegisterType(voidType); Assert.IsTrue(voidType.ConformsTo(voidType)); Classifier anyType = typesTable.Library.Any; typesTable.RegisterType(anyType); Assert.IsTrue(anyType.ConformsTo(anyType)); Classifier invalidType = typesTable.Library.Invalid; typesTable.RegisterType(invalidType); Assert.IsTrue(invalidType.ConformsTo(invalidType)); //pridat class }