public override void OnSimpleTypeReference(SimpleTypeReference node) { if (node.Name == "System.Collections.IEnumerator") { node.Name = "IEnumerator"; } }
public override void Run() { var klass = new ClassDefinition { Name = "Foo" }; var baseType = new SimpleTypeReference("object"); klass.BaseTypes.Add(baseType); var method = new Method { Name = "Bar" }; method.Body.Add( new ReturnStatement( new IntegerLiteralExpression(42))); klass.Members.Add(method); var module = CompileUnit.Modules[0]; Assert.AreEqual(0, module.Members.Count); My<CodeReifier>.Instance.ReifyInto(module, klass); Assert.AreEqual(1, module.Members.Count); Assert.AreSame(klass, module.Members[0]); var klassEntity = (IType) klass.Entity; Assert.IsTrue(klassEntity.IsClass); Assert.AreSame(TypeSystemServices.ObjectType, klassEntity.BaseType); var methodEntity = (IMethod)method.Entity; Assert.AreEqual(method.Name, methodEntity.Name); Assert.AreSame(TypeSystemServices.IntType, methodEntity.ReturnType); }
B.TypeReference ConvertTypeReference(TypeReference t) { if (t == null || t.IsNull) { return(null); } B.TypeReference r; if (t.GenericTypes.Count > 0) { r = new B.GenericTypeReference(GetLexicalInfo(t), GetIntrinsicTypeName(t.Type)); foreach (TypeReference ta in t.GenericTypes) { ((B.GenericTypeReference)r).GenericArguments.Add(ConvertTypeReference(ta)); } } else { r = new B.SimpleTypeReference(GetLexicalInfo(t), GetIntrinsicTypeName(t.Type)); } if (t.IsArrayType) { for (int i = t.RankSpecifier.Length - 1; i >= 0; --i) { r = new B.ArrayTypeReference(GetLexicalInfo(t), r, new B.IntegerLiteralExpression(t.RankSpecifier[i] + 1)); } } if (t.PointerNestingLevel != 0) { AddError(t, "Pointers are not supported by boo."); } return(r); }
public void LiftCastExpressionWithSelfTarget() { var self = new SelfLiteralExpression(); var typeReference = new SimpleTypeReference("T"); Expression cast = new TryCastExpression(self, typeReference); var parameter = ParameterDeclaration.Lift(cast); Assert.AreEqual("self", parameter.Name); Assert.IsTrue(typeReference.Matches(parameter.Type)); Assert.AreNotSame(typeReference, parameter.Type); }
public void LiftCastExpression() { var referenceExpression = new ReferenceExpression("foo"); var typeReference = new SimpleTypeReference("T"); Expression cast = new TryCastExpression(referenceExpression, typeReference); var parameter = ParameterDeclaration.Lift(cast); Assert.AreEqual(referenceExpression.Name, parameter.Name); Assert.IsTrue(typeReference.Matches(parameter.Type)); Assert.AreNotSame(typeReference, parameter.Type); }
override public object Clone() { SimpleTypeReference clone = (SimpleTypeReference)FormatterServices.GetUninitializedObject(typeof(SimpleTypeReference)); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } clone._isPointer = _isPointer; clone._name = _name; return(clone); }
override public object Clone() { SimpleTypeReference clone = new SimpleTypeReference(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } clone._isPointer = _isPointer; clone._name = _name; return(clone); }
public object VisitCompilationUnit(CompilationUnit compilationUnit, object data) { module = new B.Module(); module.LexicalInfo = new B.LexicalInfo(fileName, 1, 1); compilationUnit.AcceptChildren(this, data); if (entryPointMethod != null) { bool allMembersAreStatic = true; foreach (B.TypeMember member in entryPointMethod.DeclaringType.Members) { allMembersAreStatic &= member.IsStatic; } if (allMembersAreStatic) { entryPointMethod.DeclaringType.Attributes.Add(MakeAttribute(("module"))); } else { lastLexicalInfo = entryPointMethod.LexicalInfo; B.Expression expr = MakeReferenceExpression(entryPointMethod.DeclaringType.Name + ".Main"); B.MethodInvocationExpression mie = new B.MethodInvocationExpression(lastLexicalInfo, expr); if (entryPointMethod.Parameters.Count > 0) { mie.Arguments.Add(MakeReferenceExpression("argv")); } B.SimpleTypeReference ret = entryPointMethod.ReturnType as B.SimpleTypeReference; if (ret.Name == "void" || ret.Name == "System.Void") { module.Globals.Add(new B.ExpressionStatement(mie)); } else { module.Globals.Add(new B.ReturnStatement(lastLexicalInfo, mie, null)); } } } B.Module tmp = module; module = null; return(tmp); }
public void MergeIgnoresMatchingBaseTypes() { var foo = new SimpleTypeReference("Foo"); var bar = new SimpleTypeReference("Bar"); var fooOfBar = new GenericTypeReference("Foo", bar); var barOfFoo = new GenericTypeReference("Bar", foo); var subject = new ClassDefinition(); subject.BaseTypes.Add(bar); subject.BaseTypes.Add(fooOfBar); var node = new ClassDefinition(); node.BaseTypes.Add(foo); node.BaseTypes.Add(bar.CloneNode()); node.BaseTypes.Add(fooOfBar.CloneNode()); node.BaseTypes.Add(barOfFoo); subject.Merge(node); Assert.AreEqual(new[] { bar, fooOfBar, foo, barOfFoo }, subject.BaseTypes.ToArray()); }
B.Expression MakeReferenceExpression(TypeReference typeRef) { if (typeRef.IsArrayType) { return(new B.TypeofExpression(GetLexicalInfo(typeRef), ConvertTypeReference(typeRef))); } B.SimpleTypeReference t = (B.SimpleTypeReference)ConvertTypeReference(typeRef); B.ReferenceExpression r = MakeReferenceExpression(t.Name); if (t is B.GenericTypeReference) { B.GenericReferenceExpression gr = new B.GenericReferenceExpression(GetLexicalInfo(typeRef)); gr.Target = r; foreach (B.TypeReference tr in ((B.GenericTypeReference)t).GenericArguments) { gr.GenericArguments.Add(tr); } return(gr); } else { return(r); } }
private void GenerateConstructors(TypeDefinition definition) { ConstructorInfo[] ctors = baseClass.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); foreach (ConstructorInfo ctor in ctors) { if (ctor.IsPrivate) continue; Constructor constructor = new Constructor(definition.LexicalInfo); definition.Members.Add(constructor); MethodInvocationExpression super = new MethodInvocationExpression(new SuperLiteralExpression()); constructor.Body.Add(super); foreach (ParameterInfo info in ctor.GetParameters()) { SimpleTypeReference typeReference = new SimpleTypeReference(TypeUtilities.GetFullName(info.ParameterType)); constructor.Parameters.Add(new ParameterDeclaration(info.Name, typeReference) ); super.Arguments.Add(new ReferenceExpression(info.Name)); } } }
public override void OnSimpleTypeReference(SimpleTypeReference node) { NameResolutionService.ResolveSimpleTypeReference(node); }
public static GenericParameterDeclaration Lift(SimpleTypeReference simpleTypeRef) { return new GenericParameterDeclaration(simpleTypeRef.Name); }
private IEntity ResolveTypeName(SimpleTypeReference node) { _buffer.Clear(); if (IsQualifiedName(node.Name)) { ResolveQualifiedName(_buffer, node.Name); } else { Resolve(_buffer, node.Name, EntityType.Type); } // Remove from the buffer types that do not match requested generity FilterGenericTypes(_buffer, node); return GetEntityFromBuffer(); }
public override void OnSimpleTypeReference(SimpleTypeReference node) { MakeTypeResult(ConvertType(node)); }
public override void OnSimpleTypeReference(SimpleTypeReference node) { node.Name = this.UnityScriptTypeNameToBooTypeName(node.Name); }
public override void OnSimpleTypeReference(SimpleTypeReference node) { node.Name = UnityScriptTypeNameToCSharpTypeName(node.Name); }
private void CheckForCycles(SimpleTypeReference baseTypeRef, AbstractInternalType baseType, List visited) { if (visited.Contains(baseType.TypeDefinition)) { BaseTypeError(CompilerErrorFactory.InheritanceCycle(baseTypeRef, baseType.FullName)); return; } new BaseTypeResolution(Context, baseType.TypeDefinition, visited); }
public TypeReference simple_type_reference() { TypeReference reference = null; try { Token token = this.qname(); if ((this.LA(1) == 0x41) && (this.LA(2) == 0x5b)) { TypeReferenceCollection references; this.match(0x41); this.match(0x5b); if (base.inputState.guessing == 0) { GenericTypeReference reference2; reference = reference2 = new GenericTypeReference(ToLexicalInfo(token), token.getText()); references = reference2.get_GenericArguments(); } this.type_reference_list(references); this.match(0x5f); return reference; } if (!tokenSet_35_.member(this.LA(1)) || !tokenSet_25_.member(this.LA(2))) { throw new NoViableAltException(this.LT(1), this.getFilename()); } if (base.inputState.guessing == 0) { SimpleTypeReference reference3; SimpleTypeReference reference1 = reference3 = new SimpleTypeReference(ToLexicalInfo(token)); reference3.set_Name(token.getText()); reference = reference3; } return reference; } catch (RecognitionException exception) { if (base.inputState.guessing != 0) { throw; } this.reportError(exception); this.recover(exception, tokenSet_35_); return reference; } return reference; }
protected TypeReference type_reference() //throws RecognitionException, TokenStreamException { TypeReference tr; tr = null; IToken id = null; TypeReferenceCollection arguments = null; GenericTypeDefinitionReference gtdr = null; try { // for error handling { switch ( LA(1) ) { case SPLICE_BEGIN: { tr=splice_type_reference(); break; } case LPAREN: { tr=array_type_reference(); break; } default: bool synPredMatched251 = false; if (((LA(1)==CALLABLE) && (LA(2)==LPAREN))) { int _m251 = mark(); synPredMatched251 = true; inputState.guessing++; try { { match(CALLABLE); match(LPAREN); } } catch (RecognitionException) { synPredMatched251 = false; } rewind(_m251); inputState.guessing--; } if ( synPredMatched251 ) { { tr=callable_type_reference(); } } else if ((tokenSet_43_.member(LA(1))) && (tokenSet_44_.member(LA(2)))) { { id=type_name(); { if ((LA(1)==LBRACK) && (tokenSet_45_.member(LA(2)))) { { match(LBRACK); { switch ( LA(1) ) { case OF: { match(OF); break; } case CALLABLE: case CHAR: case THEN: case LPAREN: case ID: case MULTIPLY: case SPLICE_BEGIN: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1) ) { case MULTIPLY: { { match(MULTIPLY); if (0==inputState.guessing) { gtdr = new GenericTypeDefinitionReference(ToLexicalInfo(id)); gtdr.Name = id.getText(); gtdr.GenericPlaceholders = 1; tr = gtdr; } { // ( ... )* for (;;) { if ((LA(1)==COMMA)) { match(COMMA); match(MULTIPLY); if (0==inputState.guessing) { gtdr.GenericPlaceholders++; } } else { goto _loop260_breakloop; } } _loop260_breakloop: ; } // ( ... )* match(RBRACK); } break; } case CALLABLE: case CHAR: case THEN: case LPAREN: case ID: case SPLICE_BEGIN: { { if (0==inputState.guessing) { GenericTypeReference gtr = new GenericTypeReference(ToLexicalInfo(id), id.getText()); arguments = gtr.GenericArguments; tr = gtr; } type_reference_list(arguments); match(RBRACK); } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } } else if ((LA(1)==OF) && (LA(2)==MULTIPLY)) { { match(OF); match(MULTIPLY); if (0==inputState.guessing) { gtdr = new GenericTypeDefinitionReference(ToLexicalInfo(id)); gtdr.Name = id.getText(); gtdr.GenericPlaceholders = 1; tr = gtdr; } } } else if ((LA(1)==OF) && (tokenSet_46_.member(LA(2)))) { { match(OF); tr=type_reference(); if (0==inputState.guessing) { GenericTypeReference gtr = new GenericTypeReference(ToLexicalInfo(id), id.getText()); gtr.GenericArguments.Add(tr); tr = gtr; } } } else if ((tokenSet_44_.member(LA(1))) && (tokenSet_15_.member(LA(2)))) { if (0==inputState.guessing) { SimpleTypeReference str = new SimpleTypeReference(ToLexicalInfo(id)); str.Name = id.getText(); tr = str; } } else { throw new NoViableAltException(LT(1), getFilename()); } } { if ((LA(1)==NULLABLE_SUFFIX) && (tokenSet_44_.member(LA(2)))) { match(NULLABLE_SUFFIX); if (0==inputState.guessing) { GenericTypeReference ntr = new GenericTypeReference(tr.LexicalInfo, "System.Nullable"); ntr.GenericArguments.Add(tr); tr = ntr; } } else if ((tokenSet_44_.member(LA(1))) && (tokenSet_15_.member(LA(2)))) { } else { throw new NoViableAltException(LT(1), getFilename()); } } } } else { throw new NoViableAltException(LT(1), getFilename()); } break; } } { // ( ... )* for (;;) { if ((LA(1)==MULTIPLY) && (tokenSet_44_.member(LA(2)))) { match(MULTIPLY); if (0==inputState.guessing) { tr = CodeFactory.EnumerableTypeReferenceFor(tr); } } else if ((LA(1)==EXPONENTIATION) && (tokenSet_44_.member(LA(2)))) { match(EXPONENTIATION); if (0==inputState.guessing) { tr = CodeFactory.EnumerableTypeReferenceFor(CodeFactory.EnumerableTypeReferenceFor(tr)); } } else { goto _loop266_breakloop; } } _loop266_breakloop: ; } // ( ... )* } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "type_reference"); recover(ex,tokenSet_44_); } else { throw ex; } } return tr; }
protected override Statement ExpandImpl(MacroStatement macro) { Module module = macro.findModule(); string propname = ""; TypeReference type = new SimpleTypeReference("System.Object"); Expression initializer = null; if (macro.Arguments[0] is BinaryExpression) { var bin = macro.Arguments[0] as BinaryExpression; initializer = bin.Right; if (bin.Left is TryCastExpression) { var tce = bin.Left as TryCastExpression; propname = tce.Target.ToCodeString(); type = tce.Type ?? type; } //else //{ // propname = bin.Left.ToCodeString(); //} } //else //{ // propname = macro.Arguments[0].ToCodeString(); //} var geter = new Method("get_" + propname); geter.ReturnType = type; geter.Body = new Block(); if (initializer != null) { geter.Body.add( new IfStatement( new BinaryExpression( BinaryOperatorType.Equality, new NullLiteralExpression(), new MethodInvocationExpression( new ReferenceExpression("TryGetParameterNoIgnoreNull"), new StringLiteralExpression(propname)) ), new Block().add(new MethodInvocationExpression( new ReferenceExpression("SetProperty"), new StringLiteralExpression(propname), initializer ?? new NullLiteralExpression())) , null ) ); } var convertmethod = new GenericReferenceExpression(); convertmethod.Target = new ReferenceExpression("_convert"); convertmethod.GenericArguments.Add(type); var valuecall = new MethodInvocationExpression( new ReferenceExpression("TryGetParameterNoIgnoreNull"), new StringLiteralExpression(propname)); var convertcall = new MethodInvocationExpression(convertmethod,valuecall); geter.Body.add(new ReturnStatement(new CastExpression(convertcall, type))); var seter = new Method("set_" + propname); seter.Body = new Block().add(new MethodInvocationExpression( new ReferenceExpression("SetProperty"), new StringLiteralExpression(propname), new ReferenceExpression("value"))); var prop = new Property(geter, seter, type); prop.Name = propname; //try //{ ((TypeDefinition)module.Members[0]).Members.Insert(0, prop); //} //catch //{ // module.Members.Insert(0, prop); //in test env //} return null; }
public void try_statement(Block container) { IToken token = null; IToken token2 = null; IToken token3 = null; try { TryStatement statement; Block block; token = this.LT(1); this.match(0x2b); if (base.inputState.guessing == 0) { statement = new TryStatement(ToLexicalInfo(token)); block = statement.get_ProtectedBlock(); container.Add(statement); } this.compound_or_single_stmt(block); while (true) { TypeReference reference; if ((this.LA(1) != 7) || (this.LA(2) != 0x3f)) { break; } token2 = this.LT(1); this.match(7); this.match(0x3f); token3 = this.LT(1); this.match(0x3b); switch (this.LA(1)) { case 0x42: this.match(0x42); reference = this.type_reference(); break; case 0x40: break; default: throw new NoViableAltException(this.LT(1), this.getFilename()); } this.match(0x40); if (base.inputState.guessing == 0) { Declaration declaration; ExceptionHandler handler; if (reference == null) { reference = new SimpleTypeReference(ToLexicalInfo(token3), "System.Exception"); } ExceptionHandler handler1 = handler = new ExceptionHandler(ToLexicalInfo(token2)); Declaration declaration1 = declaration = new Declaration(ToLexicalInfo(token3)); declaration.set_Name(token3.getText()); declaration.set_Type(reference); handler.set_Declaration(declaration); ExceptionHandler handler2 = handler; statement.get_ExceptionHandlers().Add(handler2); block = handler2.get_Block(); reference = null; } this.compound_or_single_stmt(block); } if ((this.LA(1) != 0x11) || !tokenSet_2_.member(this.LA(2))) { if (!tokenSet_15_.member(this.LA(1)) || !tokenSet_20_.member(this.LA(2))) { throw new NoViableAltException(this.LT(1), this.getFilename()); } } else { this.finally_block(statement); } } catch (RecognitionException exception) { if (base.inputState.guessing != 0) { throw; } this.reportError(exception); this.recover(exception, tokenSet_15_); } }
public override void OnSimpleTypeReference(SimpleTypeReference node) { this.CheckTypeReference(node); }
public void LiftSimpleTypeReference() { var simpleTypeRef = new SimpleTypeReference("foo"); var parameter = GenericParameterDeclaration.Lift(simpleTypeRef); Assert.AreEqual(simpleTypeRef.Name, parameter.Name); }
public TypeReference CreateTypeReference(IType tag) { TypeReference typeReference = null; if (tag.IsArray) { IArrayType arrayType = (IArrayType) tag; IType elementType = arrayType.ElementType; //typeReference = new ArrayTypeReference(); //((ArrayTypeReference)typeReference).ElementType = CreateTypeReference(elementType); // FIXME: This is what it *should* be, but it causes major breakage. ?? typeReference = new ArrayTypeReference(CreateTypeReference(elementType), CreateIntegerLiteral(arrayType.Rank)); } else { typeReference = new SimpleTypeReference(tag.FullName); } typeReference.Entity = tag; return typeReference; }
private IEntity NameNotType(SimpleTypeReference node) { string suggestion = GetMostSimilarTypeName(node.Name); _context.Errors.Add(CompilerErrorFactory.NameNotType(node, node.ToCodeString(), suggestion)); return TypeSystemServices.ErrorEntity; }
private static TypeReference GetTypeReference(Type type) { TypeReference typeReference; if (type.IsGenericType) { var genericArguments = type.GetGenericArguments(); typeReference = new GenericTypeReference( TypeUtilities.GetFullName(type), genericArguments.Select(a => GetTypeReference(a)).ToArray()); } else { typeReference = new SimpleTypeReference(TypeUtilities.GetFullName(type)); } return typeReference; }
public override void OnSimpleTypeReference(SimpleTypeReference t) { Write(t.Name); }
public override void OnSimpleTypeReference(SimpleTypeReference node) { if (node.LexicalInfo != null) results.MapParsedNode(new MappedTypeReference(results, node)); base.OnSimpleTypeReference(node); }
public static GenericParameterDeclaration Lift(SimpleTypeReference simpleTypeRef) { return(new GenericParameterDeclaration(simpleTypeRef.Name)); }
public override void OnSimpleTypeReference(SimpleTypeReference node) { CheckForInnerGenericParameterReferenceUsage(node); }
public MappedTypeReference(CompileResults results, SimpleTypeReference node) : base(results, node, node.Name.Length) { }
override public object Clone() { SimpleTypeReference clone = new SimpleTypeReference(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone(); clone._isPointer = _isPointer; clone._name = _name; return clone; }
B.TypeReference ConvertTypeReference(TypeReference t) { if (t == null || t.IsNull) return null; B.TypeReference r; if (t.GenericTypes.Count > 0) { r = new B.GenericTypeReference(GetLexicalInfo(t), GetIntrinsicTypeName(t.Type)); foreach (TypeReference ta in t.GenericTypes) { ((B.GenericTypeReference)r).GenericArguments.Add(ConvertTypeReference(ta)); } } else { r = new B.SimpleTypeReference(GetLexicalInfo(t), GetIntrinsicTypeName(t.Type)); } if (t.IsArrayType) { for (int i = t.RankSpecifier.Length - 1; i >= 0; --i) { r = new B.ArrayTypeReference(GetLexicalInfo(t), r, new B.IntegerLiteralExpression(t.RankSpecifier[i] + 1)); } } if (t.PointerNestingLevel != 0) { AddError(t, "Pointers are not supported by boo."); } return r; }
public override void OnSimpleTypeReference(SimpleTypeReference node) { CheckName(node,node.Name); }
/* the simple type references that happen while visiting a * class defintion are its base class and implemented interfaces * */ public override void OnSimpleTypeReference(SimpleTypeReference node) { if (_current != null && !_current.BaseTypes.Contains(node.Name)) { _current.BaseTypes.Add(node); } }