private UstExprs.Expression VisitClassExpression(ClassExpression classExpression) { var className = classExpression.Id != null ? VisitIdentifier(classExpression.Id) : null; var baseTypes = new Collections.List <UstTokens.TypeToken>(); if (classExpression.SuperClass != null) { if (VisitExpression(classExpression.SuperClass) is UstTokens.TypeToken superClassTypeToken) { baseTypes.Add(superClassTypeToken); } } var properties = VisitClassBody(classExpression.Body); var typeDeclaration = new TypeDeclaration(null, className, properties, GetTextSpan(classExpression)) { BaseTypes = baseTypes }; return(typeDeclaration.ToExpressionIfRequired()); }
protected override void VisitClassExpression(ClassExpression expression) { CS.IndentInOut(false, "ClassExpression", () => { var characters = new SortedSet <int>(); foreach (var part in expression.Choices) { characters.UnionWith(part.Values); } var array = string.Join(",", characters.Select(c => CharRep.InCSharp(c))); var staticValue = GL.Local($"_{Cfg.CL("character-class")}"); GL.Ln($"private static int[] {staticValue} = new int[] {{{array}}};"); CS.Ln($"// {staticValue} = {{{array}}}"); var cond = expression.Negated ? "< 0" : ">= 0"; var check = characters.Count > 8 ? $"_current => Array.BinarySearch({staticValue}, _current) {cond}" : $"_current => Array.IndexOf({staticValue}, _current) {cond}"; CS.Ln($"{Locals.Result} = {Cfg.MatchPredicate}({Cfg.CurName}, {check});"); }); }
public Discovery() { Config = new Configuration(); Classes = new ClassExpression(Config); Methods = new MethodExpression(Config); Parameters = new ParameterSourceExpression(Config); }
public void TestClassExpressionGetProperties() { // Act var properties = ClassExpression.GetProperties <ClassExpressionTestClass>(); // Assert Assert.AreEqual(2, properties.Count()); }
protected override void VisitClassExpression(ClassExpression classExpression) { using (StartNodeObject(classExpression)) { Member("id", classExpression.Id); Member("superClass", classExpression.SuperClass); Member("body", classExpression.Body); } }
private ClassExpression Class(INode node) { Debug.Assert(node.Name == "class" && node.Count == 2); var invert = node[0].Count == 1; var ranges = node[1].Children.Select(SingleOrRange).ToArray(); return(ClassExpression.From(node, invert, ranges)); }
protected override void VisitClassExpression(ClassExpression expression) { var start = parsers.Count; base.VisitClassExpression(expression); var parser = new Choice(Pop(start)); parsers.Add(parser); }
protected override void VisitClassExpression(ClassExpression classExpression) { // class name identifier skipped if (classExpression.SuperClass != null) { Visit(classExpression.SuperClass); } Visit(classExpression.Body); }
public void ParseSimpleClassCommand() { Parser parser = new Parser("class Dog\na=1\nend"); var expected = new ClassExpression(new NameExpression("Dog"), new AssignExpression("a", new ConstantExpression(1))); var result = parser.ParseCommand(); Assert.IsNotNull(result); Assert.AreEqual(expected, result); Assert.IsNull(parser.ParseCommand()); }
public void ParseQualifiedClassCommand() { Parser parser = new Parser("class Animals::Dog\na=1\nend"); var expected = new ClassExpression(new DoubleColonExpression(new NameExpression("Animals"), "Dog"), new AssignExpression("a", new ConstantExpression(1))); var result = parser.ParseCommand(); Assert.IsNotNull(result); Assert.AreEqual(expected, result); Assert.IsNull(parser.ParseCommand()); }
public Convention() { Config = new Configuration(); Classes = new ClassExpression(Config); Methods = new MethodExpression(Config); Parameters = new ParameterSourceExpression(Config); CaseExecution = new CaseBehaviorExpression(Config); FixtureExecution = new FixtureBehaviorExpression(Config); ClassExecution = new ClassBehaviorExpression(Config); HideExceptionDetails = new AssertionLibraryExpression(Config); }
public Convention() { Config = new Configuration(); Classes = new ClassExpression(Config); Methods = new MethodExpression(Config);; Parameters = new ParameterSourceExpression(Config); CaseExecution = new CaseBehaviorExpression(Config); FixtureExecution = new FixtureBehaviorExpression(Config); ClassExecution = new ClassBehaviorExpression(Config); HideExceptionDetails = new AssertionLibraryExpression(Config); }
protected override void VisitClassExpression(ClassExpression expression) { void Write() { Writer.Write("["); foreach (var choice in expression.Choices) { VisitExpression(choice); } Writer.Write("]"); } LexSpaced(expression, Write); }
public void TestMySqlConnectionDeleteAllAsyncViaTableNameViaPrimaryKeys() { // Setup var tables = Database.CreateCompleteTables(10); var primaryKeys = ClassExpression.GetEntitiesPropertyValues <CompleteTable, object>(tables, e => e.Id); using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) { // Act var result = connection.DeleteAllAsync(ClassMappedNameCache.Get <CompleteTable>(), primaryKeys).Result; // Assert Assert.AreEqual(tables.Count(), result); } }
public void TestClassExpressionGetPropertiesAndValues() { // Setup var entity = GetEntities(1).First(); // Act var propertyValues = ClassExpression.GetPropertiesAndValues <ClassExpressionTestClass>(entity); // Assert Assert.AreEqual(2, propertyValues.Count()); Assert.AreEqual("Id", propertyValues.ElementAt(0).Name); Assert.AreEqual(entity.Id, propertyValues.ElementAt(0).Value); Assert.AreEqual("Property1", propertyValues.ElementAt(1).Name); Assert.AreEqual(entity.Property1, propertyValues.ElementAt(1).Value); }
public void TestSqLiteConnectionDeleteAllAsyncViaPrimaryKeys() { using (var connection = new SqliteConnection(Database.ConnectionString)) { // Setup var tables = Database.CreateCompleteTables(10, connection); var primaryKeys = ClassExpression.GetEntitiesPropertyValues <CompleteTable, object>(tables, e => e.Id); // Act var result = connection.DeleteAllAsync <CompleteTable>(primaryKeys).Result; // Assert Assert.AreEqual(tables.Count(), result); } }
public void TestSqLiteConnectionDeleteAllViaTableNameViaPrimaryKeys() { using (var connection = new SqliteConnection(Database.ConnectionStringMDS)) { // Setup var tables = Database.CreateMdsCompleteTables(10, connection); var primaryKeys = ClassExpression.GetEntitiesPropertyValues <MdsCompleteTable, object>(tables, e => e.Id); // Act var result = connection.DeleteAll(ClassMappedNameCache.Get <MdsCompleteTable>(), primaryKeys); // Assert Assert.AreEqual(tables.Count(), result); } }
public void TestMySqlConnectionDeleteAllViaPrimaryKeysBeyondLimits() { // Setup var tables = Database.CreateCompleteTables(5000); var primaryKeys = ClassExpression.GetEntitiesPropertyValues <CompleteTable, object>(tables, e => e.Id); using (var connection = new MySqlConnection(Database.ConnectionString).EnsureOpen()) { // Act var result = connection.DeleteAll <CompleteTable>(primaryKeys); // Assert Assert.AreEqual(tables.Count(), result); } }
public void TestClassExpressionGetEntitiesPropertyValuesViaField() { // Setup var entities = GetEntities(10).AsList(); // Act var propertyValues = ClassExpression.GetEntitiesPropertyValues <ClassExpressionTestClass, string>(entities, new Field("Property1")); // Assert Assert.AreEqual(entities.Count(), propertyValues.Count()); for (var i = 0; i < entities.Count(); i++) { var entity = entities.ElementAt(i); Assert.AreEqual(entity.Property1, propertyValues.ElementAt(i)); } }
public void Equals() { ClassExpression expr1 = new ClassExpression(new NameExpression("foo"), new ConstantExpression(1)); ClassExpression expr2 = new ClassExpression(new NameExpression("bar"), new ConstantExpression(1)); ClassExpression expr3 = new ClassExpression(new NameExpression("foo"), new ConstantExpression(2)); ClassExpression expr4 = new ClassExpression(new NameExpression("foo"), new ConstantExpression(1)); Assert.IsTrue(expr1.Equals(expr4)); Assert.IsTrue(expr4.Equals(expr1)); Assert.AreEqual(expr1.GetHashCode(), expr4.GetHashCode()); Assert.IsFalse(expr1.Equals(null)); Assert.IsFalse(expr1.Equals(123)); Assert.IsFalse(expr1.Equals(expr2)); Assert.IsFalse(expr2.Equals(expr1)); Assert.IsFalse(expr1.Equals(expr3)); Assert.IsFalse(expr3.Equals(expr1)); }
public void DefineSimpleClass() { Machine machine = new Machine(); Context context = machine.RootContext; StringWriter writer = new StringWriter(); context.Self.Class.SetInstanceMethod("puts", new PutsFunction(writer)); ClassExpression expr = new ClassExpression(new NameExpression("Dog"), new CallExpression("puts", new IExpression[] { new ConstantExpression(123) })); var result = expr.Evaluate(context); Assert.IsNull(result); var value = context.GetValue("Dog"); Assert.IsInstanceOfType(value, typeof(DynamicClass)); Assert.AreEqual(value, context.GetValue("Dog")); Assert.AreEqual("123\r\n", writer.ToString()); }
public void TestSqlConnectionDeleteAllForInheritedViaPrimary() { // Setup var entities = Helper.CreateInheritedIdentityTables(10); using (var connection = new SqlConnection(Database.ConnectionStringForRepoDb)) { // Act connection.InsertAll <InheritedIdentityTable>(entities); // Act var deleteResult = connection.DeleteAll <InheritedIdentityTable>( ClassExpression.GetEntitiesPropertyValues <InheritedIdentityTable, object>(entities, "Id")); // Assert Assert.AreEqual(entities.Count(), deleteResult); Assert.AreEqual(0, connection.CountAll <InheritedIdentityTable>()); } }
private static ClassExpression Class(INode node) { var parts = new List <ClassPartExpression>(); foreach (var part in node.Children.Skip(1)) { switch (part.Name) { case "range": parts.Add(ClassRangeExpression.From(part, Char.ConvertToUtf32(DecodeChar(part[0]), 0), Char.ConvertToUtf32(DecodeChar(part[1]), 0))); break; default: parts.Add(ClassCharExpression.From(part, Char.ConvertToUtf32(DecodeChar(part), 0))); break; } } return(ClassExpression.From(node, node[0].Count != 0, parts)); }
public virtual void VisitClassExpression(ClassExpression classExpression) { }
public virtual InterfaceList VisitInterfaceReferenceList(InterfaceList interfaces, Class declaringClass){ if (interfaces == null) return null; bool allowClass = declaringClass != null && declaringClass.BaseClassExpression == null; TrivialHashtable interfaceAlreadySeen = new TrivialHashtable(); for (int i = 0, n = interfaces.Count; i < n; i++) { Interface iface = (Interface)this.VisitInterfaceReference(interfaces[i]); if (iface != null && interfaceAlreadySeen[iface.UniqueKey] != null){ this.HandleError(interfaces[i], Error.DuplicateInterfaceInBaseList, this.GetTypeName(iface)); interfaces[i] = null; }else{ if (iface != null && iface.ObsoleteAttribute != null) this.CheckForObsolesence(interfaces[i], iface); InterfaceExpression ifExpr = interfaces[i] as InterfaceExpression; if (ifExpr != null){ if (i == 0 && allowClass){ ClassExpression cExpr = new ClassExpression(ifExpr.Expression, ifExpr.TemplateArguments, ifExpr.SourceContext); cExpr.DeclaringType = declaringClass; this.AddNodePositionAndInfo(ifExpr.Expression, cExpr, IdentifierContexts.TypeContext); }else this.AddNodePositionAndInfo(ifExpr.Expression, ifExpr, IdentifierContexts.TypeContext); } interfaces[i] = iface; if (iface == null) continue; interfaceAlreadySeen[iface.UniqueKey] = iface; } } return interfaces; }
public static ClassExpression IsBddStyleClassNameOrEndsWithTests(this ClassExpression expr) { return(expr.Where(type => type.Name.EndsWith("Tests") || type.Name.StartsWith("When"))); }
public static ClassExpression ConstructorDoesntHaveArguments(this ClassExpression filter) { return(filter.Where(t => t.GetConstructors(BindingFlags.Public | BindingFlags.Instance) .All(x => x.GetParameters().Length == 0))); }
public static ClassExpression ConstructorHasArguments(this ClassExpression filter) { return(filter.Where(t => t.GetConstructors(BindingFlags.Public | BindingFlags.Instance) .Any(x => x.GetParameters().Any()))); }
protected override void WalkClassExpression(ClassExpression classExpression) { this.Set(classExpression, "string"); }
public override TypeNode VisitTypeReference(TypeNode type) { if (type == null) { return(null); } Class cl = type as Class; if (cl != null) { this.VisitTypeReference(cl.BaseClass); } if (this.MembersToFind[type.UniqueKey] != null) { this.FoundMembers[type.UniqueKey] = type; if (!this.insideMethodBody) { this.AllReferencesAreConfinedToMethodBodies = false; } return(type); } switch (type.NodeType) { case NodeType.ArrayType: ArrayType arrType = (ArrayType)type; this.VisitTypeReference(arrType.ElementType); return(type); case NodeType.DelegateNode: { FunctionType ftype = type as FunctionType; if (ftype == null) { goto default; } this.VisitTypeReference(ftype.ReturnType); this.VisitParameterList(ftype.Parameters); return(type); } case NodeType.Pointer: Pointer pType = (Pointer)type; this.VisitTypeReference(pType.ElementType); return(type); case NodeType.Reference: Reference rType = (Reference)type; this.VisitTypeReference(rType.ElementType); return(type); case NodeType.TupleType: { TupleType tType = (TupleType)type; MemberList members = tType.Members; int n = members == null ? 0 : members.Count; for (int i = 0; i < n; i++) { Field f = members[i] as Field; if (f == null) { continue; } this.VisitTypeReference(f.Type); } return(type); } case NodeType.TypeIntersection: TypeIntersection tIntersect = (TypeIntersection)type; this.VisitTypeReferenceList(tIntersect.Types); return(type); case NodeType.TypeUnion: TypeUnion tUnion = (TypeUnion)type; this.VisitTypeReferenceList(tUnion.Types); return(type); case NodeType.ArrayTypeExpression: ArrayTypeExpression aExpr = (ArrayTypeExpression)type; this.VisitTypeReference(aExpr.ElementType); return(type); case NodeType.BoxedTypeExpression: BoxedTypeExpression bExpr = (BoxedTypeExpression)type; this.VisitTypeReference(bExpr.ElementType); return(type); case NodeType.ClassExpression: ClassExpression cExpr = (ClassExpression)type; this.VisitExpression(cExpr.Expression); this.VisitTypeReferenceList(cExpr.TemplateArguments); return(type); case NodeType.ClassParameter: case NodeType.TypeParameter: return(type); case NodeType.ConstrainedType: ConstrainedType conType = (ConstrainedType)type; this.VisitTypeReference(conType.UnderlyingType); this.VisitExpression(conType.Constraint); return(type); case NodeType.FlexArrayTypeExpression: FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type; this.VisitTypeReference(flExpr.ElementType); return(type); case NodeType.FunctionTypeExpression: FunctionTypeExpression ftExpr = (FunctionTypeExpression)type; this.VisitParameterList(ftExpr.Parameters); this.VisitTypeReference(ftExpr.ReturnType); return(type); case NodeType.InvariantTypeExpression: InvariantTypeExpression invExpr = (InvariantTypeExpression)type; this.VisitTypeReference(invExpr.ElementType); return(type); case NodeType.InterfaceExpression: InterfaceExpression iExpr = (InterfaceExpression)type; this.VisitExpression(iExpr.Expression); this.VisitTypeReferenceList(iExpr.TemplateArguments); return(type); case NodeType.NonEmptyStreamTypeExpression: NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type; this.VisitTypeReference(neExpr.ElementType); return(type); case NodeType.NonNullTypeExpression: NonNullTypeExpression nnExpr = (NonNullTypeExpression)type; this.VisitTypeReference(nnExpr.ElementType); return(type); case NodeType.NonNullableTypeExpression: NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type; this.VisitTypeReference(nbExpr.ElementType); return(type); case NodeType.NullableTypeExpression: NullableTypeExpression nuExpr = (NullableTypeExpression)type; this.VisitTypeReference(nuExpr.ElementType); return(type); case NodeType.OptionalModifier: case NodeType.RequiredModifier: TypeModifier modType = (TypeModifier)type; this.VisitTypeReference(modType.ModifiedType); this.VisitTypeReference(modType.Modifier); return(type); case NodeType.PointerTypeExpression: PointerTypeExpression pExpr = (PointerTypeExpression)type; this.VisitTypeReference(pExpr.ElementType); return(type); case NodeType.ReferenceTypeExpression: ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type; this.VisitTypeReference(rExpr.ElementType); return(type); case NodeType.StreamTypeExpression: StreamTypeExpression sExpr = (StreamTypeExpression)type; this.VisitTypeReference(sExpr.ElementType); return(type); case NodeType.TupleTypeExpression: TupleTypeExpression tuExpr = (TupleTypeExpression)type; this.VisitFieldList(tuExpr.Domains); return(type); case NodeType.TypeExpression: TypeExpression tExpr = (TypeExpression)type; this.VisitExpression(tExpr.Expression); this.VisitTypeReferenceList(tExpr.TemplateArguments); return(type); case NodeType.TypeIntersectionExpression: TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type; this.VisitTypeReferenceList(tiExpr.Types); return(type); case NodeType.TypeUnionExpression: TypeUnionExpression tyuExpr = (TypeUnionExpression)type; this.VisitTypeReferenceList(tyuExpr.Types); return(type); default: if (type.Template != null && type.TemplateArguments != null) { this.VisitTypeReference(type.Template); this.VisitTypeReferenceList(type.TemplateArguments); } return(type); } }
protected virtual MemberList GetMembers(int line, int col, ClassExpression cExpr, Scope scope){ if (cExpr == null) return null; MemberList members; QualifiedIdentifier qual = cExpr.Expression as QualifiedIdentifier; if (qual != null) members = this.GetMembers(line, col, qual, scope); else members = this.languageService.GetTypesNamespacesAndPrefixes(scope, false, false); if (members == null) return null; return this.GetClassesAndInterfacesAndNamespacesThatContainThem(members, cExpr.DeclaringType); }
public virtual Class VisitClassExpression(ClassExpression cexpr){ if (cexpr == null) return null; int numTemplArgs = cexpr.TemplateArgumentExpressions == null ? 0 : cexpr.TemplateArgumentExpressions.Count; TypeNode bt = this.LookupType(cexpr.Expression, false, numTemplArgs); if (bt == null){ this.HandleTypeExpected(cexpr.Expression); return null; } Class c = bt as Class; if (c != null){ if (cexpr.TemplateArguments != null){ cexpr.TemplateArguments = this.VisitTypeReferenceList(cexpr.TemplateArguments); TypeNode ti = c.GetTemplateInstance(this.currentType, cexpr.TemplateArguments); ti.TemplateExpression = cexpr; this.AddTemplateInstanceToList(ti); return (Class)ti; }else return c; }else{ return null; } }
protected override void WalkClassExpression(ClassExpression classExpression) { this.zeroWidth[classExpression] = false; }
public override TypeNode VisitTypeReference(TypeNode type) { //TODO: break up this method if (type == null) { return(null); } TypeNodeList pars = this.pars; TypeNodeList args = this.args; switch (type.NodeType) { case NodeType.ArrayType: ArrayType arrType = (ArrayType)type; TypeNode elemType = this.VisitTypeReference(arrType.ElementType); if (elemType == arrType.ElementType || elemType == null) { return(arrType); } if (arrType.IsSzArray()) { return(elemType.GetArrayType(1)); } return(elemType.GetArrayType(arrType.Rank, arrType.Sizes, arrType.LowerBounds)); case NodeType.DelegateNode: { FunctionType ftype = type as FunctionType; if (ftype == null) { goto default; } TypeNode referringType = ftype.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(ftype.DeclaringType); return(FunctionType.For(this.VisitTypeReference(ftype.ReturnType), this.VisitParameterList(ftype.Parameters), referringType)); } case NodeType.Pointer: Pointer pType = (Pointer)type; elemType = this.VisitTypeReference(pType.ElementType); if (elemType == pType.ElementType || elemType == null) { return(pType); } return(elemType.GetPointerType()); case NodeType.Reference: Reference rType = (Reference)type; elemType = this.VisitTypeReference(rType.ElementType); if (elemType == rType.ElementType || elemType == null) { return(rType); } return(elemType.GetReferenceType()); case NodeType.ArrayTypeExpression: ArrayTypeExpression aExpr = (ArrayTypeExpression)type; aExpr.ElementType = this.VisitTypeReference(aExpr.ElementType); return(aExpr); case NodeType.BoxedTypeExpression: BoxedTypeExpression bExpr = (BoxedTypeExpression)type; bExpr.ElementType = this.VisitTypeReference(bExpr.ElementType); return(bExpr); case NodeType.ClassExpression: { ClassExpression cExpr = (ClassExpression)type; cExpr.Expression = this.VisitTypeExpression(cExpr.Expression); //Could happen if the expression is a template parameter if (cExpr.Expression is Literal lit) { return(lit.Value as TypeNode); } cExpr.TemplateArguments = this.VisitTypeReferenceList(cExpr.TemplateArguments); return(cExpr); } case NodeType.ClassParameter: case NodeType.TypeParameter: int key = type.UniqueKey; for (int i = 0, n = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; i < n && i < m; i++) { //^ assert pars != null && args != null; TypeNode tp = pars[i]; if (tp == null) { continue; } if (tp.UniqueKey == key) { return(args[i]); } if (tp.Name.UniqueIdKey == type.Name.UniqueIdKey && (tp is ClassParameter && type is TypeParameter)) { //This shouldn't really happen, but in practice it does. Hack past it. return(args[i]); } } return(type); case NodeType.FlexArrayTypeExpression: FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type; flExpr.ElementType = this.VisitTypeReference(flExpr.ElementType); return(flExpr); case NodeType.FunctionTypeExpression: FunctionTypeExpression ftExpr = (FunctionTypeExpression)type; ftExpr.Parameters = this.VisitParameterList(ftExpr.Parameters); ftExpr.ReturnType = this.VisitTypeReference(ftExpr.ReturnType); return(ftExpr); case NodeType.InvariantTypeExpression: InvariantTypeExpression invExpr = (InvariantTypeExpression)type; invExpr.ElementType = this.VisitTypeReference(invExpr.ElementType); return(invExpr); case NodeType.InterfaceExpression: InterfaceExpression iExpr = (InterfaceExpression)type; if (iExpr.Expression == null) { goto default; } iExpr.Expression = this.VisitTypeExpression(iExpr.Expression); iExpr.TemplateArguments = this.VisitTypeReferenceList(iExpr.TemplateArguments); return(iExpr); case NodeType.NonEmptyStreamTypeExpression: NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type; neExpr.ElementType = this.VisitTypeReference(neExpr.ElementType); return(neExpr); case NodeType.NonNullTypeExpression: NonNullTypeExpression nnExpr = (NonNullTypeExpression)type; nnExpr.ElementType = this.VisitTypeReference(nnExpr.ElementType); return(nnExpr); case NodeType.NonNullableTypeExpression: NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type; nbExpr.ElementType = this.VisitTypeReference(nbExpr.ElementType); return(nbExpr); case NodeType.NullableTypeExpression: NullableTypeExpression nuExpr = (NullableTypeExpression)type; nuExpr.ElementType = this.VisitTypeReference(nuExpr.ElementType); return(nuExpr); case NodeType.OptionalModifier: { TypeModifier modType = (TypeModifier)type; TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType); TypeNode modifierType = this.VisitTypeReference(modType.Modifier); if (modifiedType == null || modifierType == null) { return(type); } return(OptionalModifier.For(modifierType, modifiedType)); } case NodeType.RequiredModifier: { TypeModifier modType = (TypeModifier)type; TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType); TypeNode modifierType = this.VisitTypeReference(modType.Modifier); if (modifiedType == null || modifierType == null) { Debug.Fail(""); return(type); } return(RequiredModifier.For(modifierType, modifiedType)); } case NodeType.OptionalModifierTypeExpression: OptionalModifierTypeExpression optmodType = (OptionalModifierTypeExpression)type; optmodType.ModifiedType = this.VisitTypeReference(optmodType.ModifiedType); optmodType.Modifier = this.VisitTypeReference(optmodType.Modifier); return(optmodType); case NodeType.RequiredModifierTypeExpression: RequiredModifierTypeExpression reqmodType = (RequiredModifierTypeExpression)type; reqmodType.ModifiedType = this.VisitTypeReference(reqmodType.ModifiedType); reqmodType.Modifier = this.VisitTypeReference(reqmodType.Modifier); return(reqmodType); case NodeType.PointerTypeExpression: PointerTypeExpression pExpr = (PointerTypeExpression)type; pExpr.ElementType = this.VisitTypeReference(pExpr.ElementType); return(pExpr); case NodeType.ReferenceTypeExpression: ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type; rExpr.ElementType = this.VisitTypeReference(rExpr.ElementType); return(rExpr); case NodeType.StreamTypeExpression: StreamTypeExpression sExpr = (StreamTypeExpression)type; sExpr.ElementType = this.VisitTypeReference(sExpr.ElementType); return(sExpr); case NodeType.TupleTypeExpression: TupleTypeExpression tuExpr = (TupleTypeExpression)type; tuExpr.Domains = this.VisitFieldList(tuExpr.Domains); return(tuExpr); case NodeType.TypeExpression: { TypeExpression tExpr = (TypeExpression)type; tExpr.Expression = this.VisitTypeExpression(tExpr.Expression); if (tExpr.Expression is Literal) { return(type); } tExpr.TemplateArguments = this.VisitTypeReferenceList(tExpr.TemplateArguments); return(tExpr); } case NodeType.TypeIntersectionExpression: TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type; tiExpr.Types = this.VisitTypeReferenceList(tiExpr.Types); return(tiExpr); case NodeType.TypeUnionExpression: TypeUnionExpression tyuExpr = (TypeUnionExpression)type; tyuExpr.Types = this.VisitTypeReferenceList(tyuExpr.Types); return(tyuExpr); default: TypeNode declaringType = this.VisitTypeReference(type.DeclaringType); if (declaringType != null) { Identifier tname = type.Name; if (type.Template != null && type.IsGeneric) { tname = type.Template.Name; } TypeNode nt = declaringType.GetNestedType(tname); if (nt != null) { TypeNodeList arguments = type.TemplateArguments; type = nt; if (TargetPlatform.UseGenerics) { if (arguments != null && arguments.Count > 0 && nt.ConsolidatedTemplateParameters != null && nt.ConsolidatedTemplateParameters.Count > 0) { type = nt.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, arguments); } } } } if (type.Template != null && (type.ConsolidatedTemplateParameters == null || type.ConsolidatedTemplateParameters.Count == 0)) { if (!type.IsNotFullySpecialized && (!type.IsNormalized || (this.CurrentType != null && type.DeclaringModule == this.CurrentType.DeclaringModule))) { return(type); } // Type is a template instance, but some of its arguments were themselves parameters. // See if any of these parameters are to be specialized by this specializer. bool mustSpecializeFurther = false; TypeNodeList targs = type.TemplateArguments; int numArgs = targs == null ? 0 : targs.Count; if (targs != null) { targs = new TypeNodeList(targs); for (int i = 0; i < numArgs; i++) { TypeNode targ = targs[i]; if (targ is ITypeParameter tparg) { for (int j = 0, np = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; j < np && j < m; j++) { //^ assert pars != null && args != null; if (TargetPlatform.UseGenerics) { if (!(pars[j] is ITypeParameter par)) { continue; } if (tparg == par || (tparg.ParameterListIndex == par.ParameterListIndex && tparg.DeclaringMember == par.DeclaringMember)) { targ = this.args[j]; break; } } else { if (targ == pars[j]) { targ = this.args[j]; break; } } } } else { if (targ != type) { targ = this.VisitTypeReference(targ); } if (targ == type) { continue; } } mustSpecializeFurther |= targs[i] != targ; targs[i] = targ; } } if (targs == null || !mustSpecializeFurther) { return(type); } return(type.Template.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, targs)); } TypeNodeList tPars = type.TemplateParameters; if (tPars == null || tPars.Count == 0) { return(type); //Not a parameterized type. No need to get an instance. } TypeNodeList tArgs = new TypeNodeList(); for (int i = 0, n = tPars.Count; i < n; i++) { TypeNode tPar = tPars[i]; tArgs.Add(tPar); //Leave parameter in place if there is no match if (tPar == null || tPar.Name == null) { continue; } int idKey = tPar.Name.UniqueIdKey; for (int j = 0, m = pars == null ? 0 : pars.Count, k = args == null ? 0 : args.Count; j < m && j < k; j++) { //^ assert pars != null && args != null; TypeNode par = pars[j]; if (par == null || par.Name == null) { continue; } if (par.Name.UniqueIdKey == idKey) { tArgs[i] = args[j]; break; } } } return(type.GetTemplateInstance(this.TargetModule, this.CurrentType, this.VisitTypeReference(type.DeclaringType), tArgs)); } }
public virtual void VisitBaseClassReference(Class Class){ if (Class == null) return; if (Class.Name.UniqueIdKey == StandardIds.CapitalObject.UniqueIdKey && Class.Namespace.UniqueIdKey == StandardIds.System.UniqueIdKey) { Class.BaseClass = null; Class.BaseClassExpression = null; return; } if (Class.PartiallyDefines is Class && ((Class)Class.PartiallyDefines).BaseClass == null) this.VisitBaseClassReference((Class)Class.PartiallyDefines); TypeNodeList partialTypes = Class.IsDefinedBy; if (partialTypes != null){ for (int i = 0, n = partialTypes == null ? 0 : partialTypes.Count; i < n; i++){ Class partialClass = partialTypes[i] as Class; if (partialClass == null || partialClass.BaseClass == SystemTypes.Object) continue; partialClass.PartiallyDefines = null; //Stop recursion this.VisitBaseClassReference(partialClass); partialClass.PartiallyDefines = Class; if (partialClass.BaseClass == SystemTypes.Object) continue; Class.BaseClass = partialClass.BaseClass; return; } } //Visit Class.BaseClass, but guard against doing it twice //(this routine can get called when visiting a derived class that occurs lexically before Class) if (Class.BaseClassExpression == Class) return; //Still resolving the base class. This is a recursive call due to a recursive type argument. if (Class.BaseClass != null) { ClassExpression cExpr = Class.BaseClass as ClassExpression; if (cExpr == null) return; //Been here before and found a base class this.VisitBaseClassReference(Class, true); return; } //Leaving the BaseClass null is the convention for asking that the first expression in the interface list be treated as the base class, if possible. //If not possible, the convention is to set BaseClass equal to SystemTypes.Object. InterfaceList interfaces = Class.Interfaces; InterfaceList interfaceExpressions = Class.InterfaceExpressions; if (interfaces != null && interfaces.Count > 0){ Interface iface = interfaces[0]; InterfaceExpression ifExpr = iface as InterfaceExpression; if (ifExpr != null){ ClassExpression cExpr = new ClassExpression(ifExpr.Expression, ifExpr.TemplateArguments, ifExpr.SourceContext); Class.BaseClass = Class.BaseClassExpression = cExpr; if (this.VisitBaseClassReference(Class, false)){ //The first expression is not meant as an interface, remove it from the list int n = interfaces.Count-1; InterfaceList actualInterfaces = new InterfaceList(n); InterfaceList actualInterfaceExpressions = new InterfaceList(n); for (int i = 0; i < n; i++) { actualInterfaces.Add(interfaces[i+1]); if (interfaceExpressions != null) actualInterfaceExpressions.Add(interfaceExpressions[i+1]); } Class.Interfaces = actualInterfaces; if (interfaceExpressions != null) Class.InterfaceExpressions = actualInterfaceExpressions; }else{ Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null; } }else{ Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null; } }else{ Class.BaseClass = SystemTypes.Object; Class.BaseClassExpression = null; } if (Class.BaseClass != null && Class.BaseClass != SystemTypes.Object) { this.VisitBaseClassReference(Class.BaseClass.Template as Class); this.VisitBaseClassReference(Class.BaseClass); } }