public void SetUp() { var schemaObserver = new SchemaObserver(); schemaObserver.AddKnownType(new QueryRoot()); schemaObserver.AddKnownType(new ComplicatedArgs()); schemaObserver.AddKnownType(new FurColorEnum()); schemaObserver.AddKnownType(new ComplicatedObjectType()); schemaObserver.AddKnownType(new ComplicatedInputObjectType()); var typeTranslator = new TypeTranslator(schemaObserver); this.introspector = new Introspector(typeTranslator); }
public void Equal(Expression e) { Expression lh; Expression rh; if (e is BinaryExpression) { BinaryExpression be = e as BinaryExpression; lh = be.Left; rh = be.Right; } else if (e is MethodCallExpression) { MethodCallExpression mce = e as MethodCallExpression; lh = mce.Arguments[0]; rh = mce.Arguments[1]; } else { throw new LinqToRdfException("Unrecognised equality expression type"); } if (lh != null && rh != null) { XsdtPrimitiveDataType dt = TypeTranslator.GetDataType(lh.Type); if (dt == XsdtPrimitiveDataType.XsdtString) { QueryAppend("regex("); Dispatch(lh); QueryAppend(", "); Dispatch(rh); QueryAppend(") "); } else { //QueryAppend("("); Dispatch(lh); QueryAppend(" = "); //QueryAppend(")=("); Dispatch(rh); //QueryAppend(")"); //Log("+ :{0} Handled", e.NodeType); } } else { Log("Failure during generation of Equal expression"); } }
private static void ParseWsdlArrayType(XmlReader reader, XmlAttribute attr) { if (attr.NamespaceURI == "http://schemas.xmlsoap.org/wsdl/" && attr.LocalName == "arrayType") { string text = string.Empty; string str; string str2; TypeTranslator.ParseArrayType(attr.Value, out str, out text, out str2); if (text != string.Empty) { text = reader.LookupNamespace(text) + ":"; } attr.Value = text + str + str2; } }
public override void CollectTypesInto(TranslationProcess translationProcess, SemanticModel semantics) { var classSymbol = semantics.GetDeclaredSymbol(this.OriginalNode as ClassDeclarationSyntax); // Should translate at all? var attributes = classSymbol.GetAttributes(); switch (VerificationSettings.ShouldVerify(attributes, translationProcess.Configuration.VerifyUnmarkedItems)) { case VerificationSetting.DoNotVerify: return; case VerificationSetting.Contradiction: return; } this.TypeIfCollected = translationProcess.AddToCollectedTypes(this, semantics); foreach (Sharpnode node in this.children) { // Collect fields if (node is FieldDeclarationSharpnode) { FieldDeclarationSharpnode fieldDeclaration = (FieldDeclarationSharpnode)node; var fieldSymbol = fieldDeclaration.GetSymbol(semantics); if (fieldSymbol.IsConst) { continue; // Constants are inlined. } if (fieldSymbol.IsStatic) { translationProcess.AddError(new Error(Diagnostics.SSIL108_FeatureNotSupported, node.OriginalNode, "static fields")); continue; } var typeSymbol = fieldSymbol.Type; Error error; this.TypeIfCollected.InstanceFields.Add( new CollectedField( translationProcess.IdentifierTranslator.RegisterAndGetIdentifier(((FieldDeclarationSharpnode)node).GetSymbol(semantics)), TypeTranslator.TranslateType(typeSymbol, node.OriginalNode, out error) )); if (error != null) { translationProcess.AddError(error); } } } }
public override void Run(List <ExpressionSharpnode> arguments, SyntaxNode originalNode, TranslationContext context) { // Get the symbol var methodSymbol = this._method.Symbol as IMethodSymbol; var identifier = context.Process.IdentifierTranslator.GetIdentifierReference(this._method.Symbol as IMethodSymbol); IMethodSymbol theMethod = (this._method.Symbol as IMethodSymbol); // Determine purity this.Impure = !(ContractsTranslator.IsMethodPureOrPredicate(theMethod)); // Add the receiver if (!theMethod.IsStatic) { if (this.methodGroupSharpnode is IdentifierExpressionSharpnode) { arguments.Insert(0, new DirectSilvercodeExpressionSharpnode(Constants.SilverThis, this.methodGroup)); } else if (this.methodGroupSharpnode is MemberAccessExpressionSharpnode) { arguments.Insert(0, ((MemberAccessExpressionSharpnode)this.methodGroupSharpnode).Container); } else { this.Errors.Add(new Error(Diagnostics.SSIL102_UnexpectedNode, this.methodGroup, this.methodGroup.Kind())); } } // Determine return type Error error; this.SilverType = TypeTranslator.TranslateType(methodSymbol.ReturnType, this.methodGroup, out error); if (error != null) { this.Errors.Add(error); } // Translate arguments var expressions = ConvertToSilver(arguments, context); // Put it together this.Silvernode = new CallSilvernode( identifier, expressions, this.SilverType, originalNode ); }
/// <summary> /// Prepares for insertion into quantifier. /// Returns true if this lambda expression is valid for translation inside a ForAll or Exists call; false otherwise. /// </summary> /// <param name="context">The context.</param> public bool PrepareForInsertionIntoQuantifier(TranslationContext context) { if (this.errorneousResult != null) { this.failedResult = TranslationResult.Error(this.errorneousResult.Node, this.errorneousResult.Diagnostic, this.errorneousResult.DiagnosticArguments); return(false); } // Translate the single parameter's type var parameterSymbol = context.Semantics.GetDeclaredSymbol(this.parameter.ParameterSyntax); this.VariableIdentifier = context.Process.IdentifierTranslator.RegisterAndGetIdentifier(parameterSymbol); this.VariableSilverType = TypeTranslator.TranslateType(parameterSymbol.Type, this.parameter.OriginalNode, out this.errorneousResult); if (this.errorneousResult != null) { this.failedResult = TranslationResult.Error(this.errorneousResult.Node, this.errorneousResult.Diagnostic, this.errorneousResult.DiagnosticArguments); return(false); } // Translate the lambda's body TranslationResult res = this.body.Translate(context.ChangePurityContext(PurityContext.PureOrFail)); if (res.WasTranslationSuccessful) { this.BodySilvernode = res.Silvernode; } else { this.failedResult = res; return(false); } // Nothing went wrong. return(true); }
public List<VarDeclarationNode> Walk() { var varDecls = new List<VarDeclarationNode>(); var modifiers = Modifier.None; ITree modifierNode = node.GetChild(0); if (modifierNode.Type == (int) JavaNodeType.MODIFIER_LIST) { modifiers = new ModifierListTranslator(modifierNode).Walk(); } Type type = new TypeTranslator(node.GetChild(1)).Walk(); ITree declaratorList = node.GetChild(2); for (int i = 0; i < declaratorList.ChildCount; i++) { ITree declarator = declaratorList.GetChild(i); var varDecl = new VarDeclarationNode { Modifiers = modifiers, Type = type, Name = declarator.GetChild(0).Text, }; if (declarator.ChildCount > 1) { varDecl.Initialiser = new ExpressionTranslator(declarator.GetChild(1)).Walk(); } varDecls.Add(varDecl); } return varDecls; }
public TranslationResult Translate(TranslationContext context, IParameterSymbol symbol) { Error err; ISymbol parameterSymbol = context.Semantics.GetDeclaredSymbol(this.ParameterSyntax); Identifier identifier = context.Process.IdentifierTranslator.RegisterAndGetIdentifier(parameterSymbol); ParameterSilvernode ps = new ParameterSilvernode(identifier, new TypeSilvernode(this.Type.TypeSyntax, TypeTranslator.TranslateType(symbol.Type, this.Type.TypeSyntax, out err)), this.OriginalNode); var errlist = new List <Error>(); if (err != null) { errlist.Add(err); } return(TranslationResult.FromSilvernode(ps, errlist)); }
public void Constant(Expression e) { ConstantExpression ce = (ConstantExpression)e; QueryAppend(TypeTranslator.Get(e.Type, ce.Value).ToString()); }