Source code

001// Copyright 2007-2023 The Apache Software Foundation
002//
003// Licensed under the Apache License, Version 2.0 (the "License");
004// you may not use this file except in compliance with the License.
005// You may obtain a copy of the License at
006//
007// http://www.apache.org/licenses/LICENSE-2.0
008//
009// Unless required by applicable law or agreed to in writing, software
010// distributed under the License is distributed on an "AS IS" BASIS,
011// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012// See the License for the specific language governing permissions and
013// limitations under the License.
014
015package org.apache.tapestry5.beanmodel.internal.services;
016
017import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.DECIMAL;
018import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.DEREF;
019import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.FALSE;
020import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.IDENTIFIER;
021import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.INTEGER;
022import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.INVOKE;
023import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.LIST;
024import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.MAP;
025import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.NOT;
026import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.NULL;
027import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.RANGEOP;
028import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.SAFEDEREF;
029import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.STRING;
030import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.THIS;
031import static org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser.TRUE;
032
033import org.apache.tapestry5.ioc.annotations.ComponentLayer;
034import java.io.ByteArrayInputStream;
035import java.io.IOException;
036import java.io.InputStream;
037import java.lang.annotation.Annotation;
038import java.lang.reflect.Field;
039import java.lang.reflect.Member;
040import java.lang.reflect.Method;
041import java.lang.reflect.Modifier;
042import java.lang.reflect.Type;
043import java.util.ArrayList;
044import java.util.Collections;
045import java.util.HashMap;
046import java.util.Iterator;
047import java.util.List;
048import java.util.Map;
049import java.util.Map.Entry;
050
051import org.antlr.runtime.ANTLRInputStream;
052import org.antlr.runtime.CommonTokenStream;
053import org.antlr.runtime.tree.Tree;
054import org.apache.tapestry5.beanmodel.PropertyConduit;
055import org.apache.tapestry5.beanmodel.PropertyConduit2;
056import org.apache.tapestry5.beanmodel.internal.InternalPropertyConduit;
057import org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionLexer;
058import org.apache.tapestry5.beanmodel.internal.antlr.PropertyExpressionParser;
059import org.apache.tapestry5.beanmodel.services.PropertyConduitSource;
060import org.apache.tapestry5.commons.AnnotationProvider;
061import org.apache.tapestry5.commons.internal.NullAnnotationProvider;
062import org.apache.tapestry5.commons.internal.services.StringInterner;
063import org.apache.tapestry5.commons.internal.util.GenericsUtils;
064import org.apache.tapestry5.commons.internal.util.InternalCommonsUtils;
065import org.apache.tapestry5.commons.services.ClassPropertyAdapter;
066import org.apache.tapestry5.commons.services.InvalidationEventHub;
067import org.apache.tapestry5.commons.services.PlasticProxyFactory;
068import org.apache.tapestry5.commons.services.PropertyAccess;
069import org.apache.tapestry5.commons.services.PropertyAdapter;
070import org.apache.tapestry5.commons.services.TypeCoercer;
071import org.apache.tapestry5.commons.util.AvailableValues;
072import org.apache.tapestry5.commons.util.CollectionFactory;
073import org.apache.tapestry5.commons.util.ExceptionUtils;
074import org.apache.tapestry5.commons.util.IntegerRange;
075import org.apache.tapestry5.commons.util.MultiKey;
076import org.apache.tapestry5.commons.util.UnknownValueException;
077import org.apache.tapestry5.ioc.annotations.ComponentClasses;
078import org.apache.tapestry5.ioc.annotations.PostInjection;
079import org.apache.tapestry5.plastic.Condition;
080import org.apache.tapestry5.plastic.InstructionBuilder;
081import org.apache.tapestry5.plastic.InstructionBuilderCallback;
082import org.apache.tapestry5.plastic.MethodDescription;
083import org.apache.tapestry5.plastic.PlasticClass;
084import org.apache.tapestry5.plastic.PlasticClassTransformer;
085import org.apache.tapestry5.plastic.PlasticField;
086import org.apache.tapestry5.plastic.PlasticMethod;
087import org.apache.tapestry5.plastic.PlasticUtils;
088
089public class PropertyConduitSourceImpl implements PropertyConduitSource
090{
091    static class ConduitMethods
092    {
093        private static final MethodDescription GET = getMethodDescription(PropertyConduit.class, "get", Object.class);
094
095        private static final MethodDescription SET = getMethodDescription(PropertyConduit.class, "set", Object.class,
096                Object.class);
097
098        private static final MethodDescription GET_PROPERTY_TYPE = getMethodDescription(PropertyConduit.class,
099                "getPropertyType");
100
101        private static final MethodDescription GET_PROPERTY_GENERIC_TYPE = getMethodDescription(PropertyConduit2.class,
102                "getPropertyGenericType");
103        
104        private static final MethodDescription GET_PROPERTY_NAME = getMethodDescription(InternalPropertyConduit.class,
105                "getPropertyName");
106        
107        private static final MethodDescription GET_ANNOTATION = getMethodDescription(AnnotationProvider.class,
108                "getAnnotation", Class.class);
109
110    }
111
112    static class DelegateMethods
113    {
114        static final Method INVERT = getMethod(PropertyConduitDelegate.class, "invert", Object.class);
115
116        static final Method RANGE = getMethod(PropertyConduitDelegate.class, "range", int.class, int.class);
117
118        static final Method COERCE = getMethod(PropertyConduitDelegate.class, "coerce", Object.class, Class.class);
119    }
120
121    static class ArrayListMethods
122    {
123        static final Method ADD = getMethod(ArrayList.class, "add", Object.class);
124    }
125
126    static class HashMapMethods
127    {
128        static final Method PUT = getMethod(HashMap.class, "put", Object.class, Object.class);
129    }
130
131    private static InstructionBuilderCallback RETURN_NULL = new InstructionBuilderCallback()
132    {
133        public void doBuild(InstructionBuilder builder)
134        {
135            builder.loadNull().returnResult();
136        }
137    };
138
139    private static final String[] SINGLE_OBJECT_ARGUMENT = new String[]
140            {Object.class.getName()};
141
142    @SuppressWarnings("unchecked")
143    private static Method getMethod(Class containingClass, String name, Class... parameterTypes)
144    {
145        try
146        {
147            return containingClass.getMethod(name, parameterTypes);
148        } catch (NoSuchMethodException ex)
149        {
150            throw new IllegalArgumentException(ex);
151        }
152    }
153
154    private static MethodDescription getMethodDescription(Class containingClass, String name, Class... parameterTypes)
155    {
156        return new MethodDescription(getMethod(containingClass, name, parameterTypes));
157    }
158
159    private final AnnotationProvider nullAnnotationProvider = new NullAnnotationProvider();
160
161    /**
162     * How are null values in intermdiate terms to be handled?
163     */
164    private enum NullHandling
165    {
166        /**
167         * Add code to check for null and throw exception if null.
168         */
169        FORBID,
170
171        /**
172         * Add code to check for null and short-circuit (i.e., the "?."
173         * safe-dereference operator)
174         */
175        ALLOW
176    }
177
178    /**
179     * One term in an expression. Expressions start with some root type and each term advances
180     * to a new type.
181     */
182    private class Term
183    {
184        /**
185         * The generic type of the term.
186         */
187        final Type type;
188
189        final Class genericType;
190
191        /**
192         * Describes the term, for use in error messages.
193         */
194        final String description;
195
196        final AnnotationProvider annotationProvider;
197
198        /**
199         * Callback that will implement the term.
200         */
201        final InstructionBuilderCallback callback;
202
203        Term(Type type, Class genericType, String description, AnnotationProvider annotationProvider,
204             InstructionBuilderCallback callback)
205        {
206            this.type = type;
207            this.genericType = genericType;
208            this.description = description;
209            this.annotationProvider = annotationProvider;
210            this.callback = callback;
211        }
212
213        Term(Type type, String description, AnnotationProvider annotationProvider, InstructionBuilderCallback callback)
214        {
215            this(type, GenericsUtils.asClass(type), description, annotationProvider, callback);
216        }
217
218        Term(Type type, String description, InstructionBuilderCallback callback)
219        {
220            this(type, description, null, callback);
221        }
222
223        /**
224         * Returns a clone of this Term with a new callback.
225         */
226        Term withCallback(InstructionBuilderCallback newCallback)
227        {
228            return new Term(type, genericType, description, annotationProvider, newCallback);
229        }
230    }
231
232    private final PropertyAccess access;
233
234    private final PlasticProxyFactory proxyFactory;
235
236    private final TypeCoercer typeCoercer;
237
238    private final StringInterner interner;
239
240    /**
241     * Keyed on combination of root class and expression.
242     */
243    private final Map<MultiKey, PropertyConduit> cache = CollectionFactory.newConcurrentMap();
244
245    private final Invariant invariantAnnotation = new Invariant()
246    {
247        public Class<? extends Annotation> annotationType()
248        {
249            return Invariant.class;
250        }
251    };
252
253    private final AnnotationProvider invariantAnnotationProvider = new AnnotationProvider()
254    {
255        public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
256        {
257            if (annotationClass == Invariant.class)
258                return annotationClass.cast(invariantAnnotation);
259
260            return null;
261        }
262    };
263
264    private final PropertyConduit literalTrue;
265
266    private final PropertyConduit literalFalse;
267
268    private final PropertyConduit literalNull;
269
270    private final PropertyConduitDelegate sharedDelegate;
271
272    /**
273     * Encapsulates the process of building a PropertyConduit instance from an
274     * expression, as an {@link PlasticClassTransformer}.
275     */
276    class PropertyConduitBuilder implements PlasticClassTransformer
277    {
278        private final Class rootType;
279
280        private final String expression;
281
282        private final Tree tree;
283
284        private Class conduitPropertyType;
285
286        private Type conduitPropertyGenericType;
287
288        private String conduitPropertyName;
289
290        private AnnotationProvider annotationProvider = nullAnnotationProvider;
291
292        private PlasticField delegateField;
293
294        private PlasticClass plasticClass;
295
296        private PlasticMethod getRootMethod, navMethod;
297
298        PropertyConduitBuilder(Class rootType, String expression, Tree tree)
299        {
300            this.rootType = rootType;
301            this.expression = expression;
302            this.tree = tree;
303        }
304
305        public void transform(PlasticClass plasticClass)
306        {
307            this.plasticClass = plasticClass;
308
309            // Create the various methods; also determine the conduit's property type, property name and identify
310            // the annotation provider.
311
312            implementNavMethodAndAccessors();
313
314            implementOtherMethods();
315
316            plasticClass.addToString(String.format("PropertyConduit[%s %s]", rootType.getName(), expression));
317        }
318
319        private void implementOtherMethods()
320        {
321            PlasticField annotationProviderField = plasticClass.introduceField(AnnotationProvider.class,
322                    "annotationProvider").inject(annotationProvider);
323
324            plasticClass.introduceMethod(ConduitMethods.GET_ANNOTATION).delegateTo(annotationProviderField);
325
326            plasticClass.introduceMethod(ConduitMethods.GET_PROPERTY_NAME, new InstructionBuilderCallback()
327            {
328                public void doBuild(InstructionBuilder builder)
329                {
330                    builder.loadConstant(conduitPropertyName).returnResult();
331                }
332            });
333
334            final PlasticField propertyTypeField = plasticClass.introduceField(Class.class, "propertyType").inject(
335                    conduitPropertyType);
336
337            plasticClass.introduceMethod(ConduitMethods.GET_PROPERTY_TYPE, new InstructionBuilderCallback()
338            {
339                public void doBuild(InstructionBuilder builder)
340                {
341                    builder.loadThis().getField(propertyTypeField).returnResult();
342                }
343            });
344
345            final PlasticField propertyGenericTypeField = plasticClass.introduceField(Type.class, "propertyGenericType").inject(
346                    conduitPropertyGenericType);
347
348            plasticClass.introduceMethod(ConduitMethods.GET_PROPERTY_GENERIC_TYPE, new InstructionBuilderCallback()
349            {
350                public void doBuild(InstructionBuilder builder)
351                {
352                    builder.loadThis().getField(propertyGenericTypeField).returnResult();
353                }
354            });
355        }
356
357        /**
358         * Creates a method that does a conversion from Object to the expected root type, with
359         * a null check.
360         */
361        private void implementGetRoot()
362        {
363            getRootMethod = plasticClass.introducePrivateMethod(PlasticUtils.toTypeName(rootType), "getRoot",
364                    SINGLE_OBJECT_ARGUMENT, null);
365
366            getRootMethod.changeImplementation(new InstructionBuilderCallback()
367            {
368                public void doBuild(InstructionBuilder builder)
369                {
370                    builder.loadArgument(0).dupe().when(Condition.NULL, new InstructionBuilderCallback()
371                    {
372                        public void doBuild(InstructionBuilder builder)
373                        {
374                            builder.throwException(NullPointerException.class,
375                                    String.format("Root object of property expression '%s' is null.", expression));
376                        }
377                    });
378
379                    builder.checkcast(rootType).returnResult();
380                }
381            });
382        }
383
384        private boolean isLeaf(Tree node)
385        {
386            int type = node.getType();
387
388            return type != DEREF && type != SAFEDEREF;
389        }
390
391        private void implementNavMethodAndAccessors()
392        {
393            implementGetRoot();
394
395            // First, create the navigate method.
396
397            final List<InstructionBuilderCallback> callbacks = CollectionFactory.newList();
398
399            Type activeType = rootType;
400
401            Tree node = tree;
402
403            while (!isLeaf(node))
404            {
405                Term term = analyzeDerefNode(activeType, node);
406
407                callbacks.add(term.callback);
408
409                activeType = term.type;
410
411                // Second term is the continuation, possibly another chained
412                // DEREF, etc.
413                node = node.getChild(1);
414            }
415
416            Class activeClass = GenericsUtils.asClass(activeType);
417
418            if (callbacks.isEmpty())
419            {
420                navMethod = getRootMethod;
421            } else
422            {
423                navMethod = plasticClass.introducePrivateMethod(PlasticUtils.toTypeName(activeClass), "navigate",
424                        SINGLE_OBJECT_ARGUMENT, null);
425
426                navMethod.changeImplementation(new InstructionBuilderCallback()
427                {
428                    public void doBuild(InstructionBuilder builder)
429                    {
430                        builder.loadThis().loadArgument(0).invokeVirtual(getRootMethod);
431
432                        for (InstructionBuilderCallback callback : callbacks)
433                        {
434                            callback.doBuild(builder);
435                        }
436
437                        builder.returnResult();
438                    }
439                });
440            }
441
442            implementAccessors(activeType, node);
443        }
444
445        private void implementAccessors(Type activeType, Tree node)
446        {
447            switch (node.getType())
448            {
449                case IDENTIFIER:
450
451                    implementPropertyAccessors(activeType, node);
452
453                    return;
454
455                case INVOKE:
456
457                    // So, at this point, we have the navigation method written
458                    // and it covers all but the terminal
459                    // de-reference. node is an IDENTIFIER or INVOKE. We're
460                    // ready to use the navigation
461                    // method to implement get() and set().
462
463                    implementMethodAccessors(activeType, node);
464
465                    return;
466
467                case RANGEOP:
468
469                    // As currently implemented, RANGEOP can only appear as the
470                    // top level, which
471                    // means we didn't need the navigate method after all.
472
473                    implementRangeOpGetter(node);
474                    implementNoOpSetter();
475
476                    conduitPropertyType = IntegerRange.class;
477                    conduitPropertyGenericType = IntegerRange.class;
478
479                    return;
480
481                case LIST:
482
483                    implementListGetter(node);
484                    implementNoOpSetter();
485
486                    conduitPropertyType = List.class;
487                    conduitPropertyGenericType = List.class;
488                    
489                    return;
490
491                case MAP:
492                    implementMapGetter(node);
493                    implementNoOpSetter();
494
495                    conduitPropertyType = Map.class;
496                    conduitPropertyGenericType = Map.class;
497
498                    return;
499
500
501                case NOT:
502                    implementNotOpGetter(node);
503                    implementNoOpSetter();
504
505                    conduitPropertyType = boolean.class;
506                    conduitPropertyGenericType = boolean.class;
507
508                    return;
509
510                default:
511                    throw unexpectedNodeType(node, IDENTIFIER, INVOKE, RANGEOP, LIST, NOT);
512            }
513        }
514
515        public void implementMethodAccessors(final Type activeType, final Tree invokeNode)
516        {
517            final Term term = buildInvokeTerm(activeType, invokeNode);
518
519            implementNoOpSetter();
520
521            conduitPropertyName = term.description;
522            conduitPropertyType = term.genericType;
523            conduitPropertyGenericType = term.genericType;
524            annotationProvider = term.annotationProvider;
525
526            plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
527            {
528                public void doBuild(InstructionBuilder builder)
529                {
530                    invokeNavigateMethod(builder);
531
532                    term.callback.doBuild(builder);
533
534                    boxIfPrimitive(builder, conduitPropertyType);
535
536                    builder.returnResult();
537                }
538            });
539
540            implementNoOpSetter();
541        }
542
543        public void implementPropertyAccessors(Type activeType, Tree identifierNode)
544        {
545            String propertyName = identifierNode.getText();
546
547            PropertyAdapter adapter = findPropertyAdapter(activeType, propertyName);
548
549            conduitPropertyName = propertyName;
550            conduitPropertyType = adapter.getType();
551            conduitPropertyGenericType = getGenericType(adapter);
552            annotationProvider = adapter;
553
554            implementGetter(adapter);
555            implementSetter(adapter);
556        }
557
558        private Type getGenericType(PropertyAdapter adapter)
559        {
560            Type genericType = null;
561            if (adapter.getField() != null)
562            {
563                genericType = adapter.getField().getGenericType();
564            }
565            else if (adapter.getReadMethod() != null)
566            {
567                genericType = adapter.getReadMethod().getGenericReturnType(); 
568            }
569            else if (adapter.getWriteMethod() != null)
570            {
571                genericType = adapter.getWriteMethod().getGenericParameterTypes()[0];
572            }
573            else
574            {
575                throw new RuntimeException("Could not find accessor for property " + adapter.getName());
576            }
577            
578            return genericType == null ? adapter.getType() : genericType;
579        }
580
581        private void implementSetter(PropertyAdapter adapter)
582        {
583            if (adapter.getWriteMethod() != null)
584            {
585                implementSetter(adapter.getWriteMethod());
586                return;
587            }
588
589            if (adapter.getField() != null && adapter.isUpdate())
590            {
591                implementSetter(adapter.getField());
592                return;
593            }
594
595            implementNoOpMethod(ConduitMethods.SET, "Expression '%s' for class %s is read-only.", expression,
596                    rootType.getName());
597        }
598
599        private boolean isStatic(Member member)
600        {
601            return Modifier.isStatic(member.getModifiers());
602        }
603
604        private void implementSetter(final Field field)
605        {
606            if (isStatic(field))
607            {
608                plasticClass.introduceMethod(ConduitMethods.SET, new InstructionBuilderCallback()
609                {
610                    public void doBuild(InstructionBuilder builder)
611                    {
612                        builder.loadArgument(1).castOrUnbox(PlasticUtils.toTypeName(field.getType()));
613
614                        builder.putStaticField(field.getDeclaringClass().getName(), field.getName(), field.getType());
615
616                        builder.returnResult();
617                    }
618                });
619
620                return;
621            }
622
623            plasticClass.introduceMethod(ConduitMethods.SET, new InstructionBuilderCallback()
624            {
625                public void doBuild(InstructionBuilder builder)
626                {
627                    invokeNavigateMethod(builder);
628
629                    builder.loadArgument(1).castOrUnbox(PlasticUtils.toTypeName(field.getType()));
630
631                    builder.putField(field.getDeclaringClass().getName(), field.getName(), field.getType());
632
633                    builder.returnResult();
634                }
635            });
636        }
637
638        private void implementSetter(final Method writeMethod)
639        {
640            plasticClass.introduceMethod(ConduitMethods.SET, new InstructionBuilderCallback()
641            {
642                public void doBuild(InstructionBuilder builder)
643                {
644                    invokeNavigateMethod(builder);
645
646                    Class propertyType = writeMethod.getParameterTypes()[0];
647                    String propertyTypeName = PlasticUtils.toTypeName(propertyType);
648
649                    builder.loadArgument(1).castOrUnbox(propertyTypeName);
650
651                    builder.invoke(writeMethod);
652
653                    builder.returnResult();
654                }
655            });
656        }
657
658        private void implementGetter(PropertyAdapter adapter)
659        {
660            if (adapter.getReadMethod() != null)
661            {
662                implementGetter(adapter.getReadMethod());
663                return;
664            }
665
666            if (adapter.getField() != null)
667            {
668                implementGetter(adapter.getField());
669                return;
670            }
671
672            implementNoOpMethod(ConduitMethods.GET, "Expression '%s' for class %s is write-only.", expression,
673                    rootType.getName());
674        }
675
676        private void implementGetter(final Field field)
677        {
678            if (isStatic(field))
679            {
680                plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
681                {
682                    public void doBuild(InstructionBuilder builder)
683                    {
684                        builder.getStaticField(field.getDeclaringClass().getName(), field.getName(), field.getType());
685
686                        // Cast not necessary here since the return type of get() is Object
687
688                        boxIfPrimitive(builder, field.getType());
689
690                        builder.returnResult();
691                    }
692                });
693
694                return;
695            }
696
697            plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
698            {
699                public void doBuild(InstructionBuilder builder)
700                {
701                    invokeNavigateMethod(builder);
702
703                    builder.getField(field.getDeclaringClass().getName(), field.getName(), field.getType());
704
705                    // Cast not necessary here since the return type of get() is Object
706
707                    boxIfPrimitive(builder, field.getType());
708
709                    builder.returnResult();
710                }
711            });
712        }
713
714        private void implementGetter(final Method readMethod)
715        {
716            plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
717            {
718                public void doBuild(InstructionBuilder builder)
719                {
720                    invokeNavigateMethod(builder);
721
722                    invokeMethod(builder, readMethod, null, 0);
723
724                    boxIfPrimitive(builder, conduitPropertyType);
725
726                    builder.returnResult();
727                }
728            });
729        }
730
731        private void implementRangeOpGetter(final Tree rangeNode)
732        {
733            plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
734            {
735                public void doBuild(InstructionBuilder builder)
736                {
737                    // Put the delegate on top of the stack
738
739                    builder.loadThis().getField(getDelegateField());
740
741                    invokeMethod(builder, DelegateMethods.RANGE, rangeNode, 0);
742
743                    builder.returnResult();
744                }
745            });
746        }
747
748        /**
749         * @param node
750         *         subexpression to invert
751         */
752        private void implementNotOpGetter(final Tree node)
753        {
754            // Implement get() as navigate, then do a method invocation based on node
755            // then, then pass (wrapped) result to delegate.invert()
756
757            plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
758            {
759                public void doBuild(InstructionBuilder builder)
760                {
761                    Type expressionType = implementNotExpression(builder, node);
762
763                    // Yes, we know this will always be the case, for now.
764
765                    boxIfPrimitive(builder, expressionType);
766
767                    builder.returnResult();
768                }
769            });
770        }
771
772        /**
773         * The first part of any implementation of get() or set(): invoke the navigation method
774         * and if the result is null, return immediately.
775         */
776        private void invokeNavigateMethod(InstructionBuilder builder)
777        {
778            builder.loadThis().loadArgument(0).invokeVirtual(navMethod);
779
780            builder.dupe().when(Condition.NULL, RETURN_NULL);
781        }
782
783        /**
784         * Uses the builder to add instructions for a subexpression.
785         *
786         * @param builder
787         *         used to add instructions
788         * @param activeType
789         *         type of value on top of the stack when this code will execute, or null if no value on stack
790         * @param node
791         *         defines the expression
792         * @return the expression type
793         */
794        private Type implementSubexpression(InstructionBuilder builder, Type activeType, Tree node)
795        {
796            Term term;
797
798            while (true)
799            {
800                switch (node.getType())
801                {
802                    case IDENTIFIER:
803                    case INVOKE:
804
805                        if (activeType == null)
806                        {
807                            invokeGetRootMethod(builder);
808
809                            activeType = rootType;
810                        }
811
812                        term = buildTerm(activeType, node);
813
814                        term.callback.doBuild(builder);
815
816                        return term.type;
817
818                    case INTEGER:
819
820                        builder.loadConstant(Long.valueOf(node.getText()));
821
822                        return long.class;
823
824                    case DECIMAL:
825
826                        builder.loadConstant(Double.valueOf(node.getText()));
827
828                        return double.class;
829
830                    case STRING:
831
832                        builder.loadConstant(node.getText());
833
834                        return String.class;
835
836                    case DEREF:
837                    case SAFEDEREF:
838
839                        if (activeType == null)
840                        {
841                            invokeGetRootMethod(builder);
842
843                            activeType = rootType;
844                        }
845
846                        term = analyzeDerefNode(activeType, node);
847
848                        term.callback.doBuild(builder);
849
850                        activeType = GenericsUtils.asClass(term.type);
851
852                        node = node.getChild(1);
853
854                        break;
855
856                    case TRUE:
857                    case FALSE:
858
859                        builder.loadConstant(node.getType() == TRUE ? 1 : 0);
860
861                        return boolean.class;
862
863                    case LIST:
864
865                        return implementListConstructor(builder, node);
866
867                    case MAP:
868                        return implementMapConstructor(builder, node);
869
870                    case NOT:
871
872                        return implementNotExpression(builder, node);
873
874                    case THIS:
875
876                        invokeGetRootMethod(builder);
877
878                        return rootType;
879
880                    case NULL:
881
882                        builder.loadNull();
883
884                        return Void.class;
885
886                    default:
887                        throw unexpectedNodeType(node, TRUE, FALSE, INTEGER, DECIMAL, STRING, DEREF, SAFEDEREF,
888                                IDENTIFIER, INVOKE, LIST, NOT, THIS, NULL);
889                }
890            }
891        }
892
893        public void invokeGetRootMethod(InstructionBuilder builder)
894        {
895            builder.loadThis().loadArgument(0).invokeVirtual(getRootMethod);
896        }
897
898        private void implementListGetter(final Tree listNode)
899        {
900            plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
901            {
902                public void doBuild(InstructionBuilder builder)
903                {
904                    implementListConstructor(builder, listNode);
905
906                    builder.returnResult();
907                }
908            });
909        }
910
911        private Type implementListConstructor(InstructionBuilder builder, Tree listNode)
912        {
913            // First, create an empty instance of ArrayList
914
915            int count = listNode.getChildCount();
916
917            builder.newInstance(ArrayList.class);
918            builder.dupe().loadConstant(count).invokeConstructor(ArrayList.class, int.class);
919
920            for (int i = 0; i < count; i++)
921            {
922                builder.dupe(); // the ArrayList
923
924                Type expressionType = implementSubexpression(builder, null, listNode.getChild(i));
925
926                boxIfPrimitive(builder, GenericsUtils.asClass(expressionType));
927
928                // Add the value to the array, then pop off the returned boolean
929                builder.invoke(ArrayListMethods.ADD).pop();
930            }
931
932            return ArrayList.class;
933        }
934
935        private void implementMapGetter(final Tree mapNode)
936        {
937            plasticClass.introduceMethod(ConduitMethods.GET, new InstructionBuilderCallback()
938            {
939                public void doBuild(InstructionBuilder builder)
940                {
941                    implementMapConstructor(builder, mapNode);
942
943                    builder.returnResult();
944                }
945            });
946        }
947
948        private Type implementMapConstructor(InstructionBuilder builder, Tree mapNode)
949        {
950            int count = mapNode.getChildCount();
951            builder.newInstance(HashMap.class);
952            builder.dupe().loadConstant(count).invokeConstructor(HashMap.class, int.class);
953
954            for (int i = 0; i < count; i += 2)
955            {
956                builder.dupe();
957
958                //build the key:
959                Type keyType = implementSubexpression(builder, null, mapNode.getChild(i));
960                boxIfPrimitive(builder, GenericsUtils.asClass(keyType));
961
962                //and the value:
963                Type valueType = implementSubexpression(builder, null, mapNode.getChild(i + 1));
964                boxIfPrimitive(builder, GenericsUtils.asClass(valueType));
965
966                //put the value into the array, then pop off the returned object.
967                builder.invoke(HashMapMethods.PUT).pop();
968
969            }
970
971            return HashMap.class;
972        }
973
974
975        private void implementNoOpSetter()
976        {
977            implementNoOpMethod(ConduitMethods.SET, "Expression '%s' for class %s is read-only.", expression,
978                    rootType.getName());
979        }
980
981        public void implementNoOpMethod(MethodDescription method, String format, Object... arguments)
982        {
983            final String message = String.format(format, arguments);
984
985            plasticClass.introduceMethod(method).changeImplementation(new InstructionBuilderCallback()
986            {
987                public void doBuild(InstructionBuilder builder)
988                {
989                    builder.throwException(RuntimeException.class, message);
990                }
991            });
992        }
993
994        /**
995         * Invokes a method that may take parameters. The children of the invokeNode are subexpressions
996         * to be evaluated, and potentially coerced, so that they may be passed to the method.
997         *
998         * @param builder
999         *         constructs code
1000         * @param method
1001         *         method to invoke
1002         * @param node
1003         *         INVOKE or RANGEOP node
1004         * @param childOffset
1005         *         offset within the node to the first child expression (1 in an INVOKE node because the
1006         *         first child is the method name, 0 in a RANGEOP node)
1007         */
1008        private void invokeMethod(InstructionBuilder builder, Method method, Tree node, int childOffset)
1009        {
1010            // We start with the target object for the method on top of the stack.
1011            // Next, we have to push each method parameter, which may include boxing/deboxing
1012            // and coercion. Once the code is in good shape, there's a lot of room to optimize
1013            // the bytecode (a bit too much boxing/deboxing occurs, as well as some unnecessary
1014            // trips through TypeCoercer). We might also want to have a local variable to store
1015            // the root object (result of getRoot()).
1016
1017            Class[] parameterTypes = method.getParameterTypes();
1018
1019            for (int i = 0; i < parameterTypes.length; i++)
1020            {
1021                Type expressionType = implementSubexpression(builder, null, node.getChild(i + childOffset));
1022
1023                // The value left on the stack is not primitive, and expressionType represents
1024                // its real type.
1025
1026                Class parameterType = parameterTypes[i];
1027
1028                if (!parameterType.isAssignableFrom(GenericsUtils.asClass(expressionType)))
1029                {
1030                    boxIfPrimitive(builder, expressionType);
1031
1032                    builder.loadThis().getField(getDelegateField());
1033                    builder.swap().loadTypeConstant(PlasticUtils.toWrapperType(parameterType));
1034                    builder.invoke(DelegateMethods.COERCE);
1035
1036                    if (parameterType.isPrimitive())
1037                    {
1038                        builder.castOrUnbox(parameterType.getName());
1039                    } else
1040                    {
1041                        builder.checkcast(parameterType);
1042                    }
1043                }
1044
1045                // And that should leave an object of the correct type on the stack,
1046                // ready for the method invocation.
1047            }
1048
1049            // Now the target object and all parameters are in place.
1050
1051            builder.invoke(method.getDeclaringClass(), method.getReturnType(), method.getName(),
1052                    method.getParameterTypes());
1053        }
1054
1055        /**
1056         * Analyzes a DEREF or SAFEDEREF node, proving back a term that identifies its type and provides a callback to
1057         * peform the dereference.
1058         *
1059         * @return a term indicating the type of the expression to this point, and a {@link InstructionBuilderCallback}
1060         *         to advance the evaluation of the expression form the previous value to the current
1061         */
1062        private Term analyzeDerefNode(Type activeType, Tree node)
1063        {
1064            // The first child is the term.
1065
1066            Tree term = node.getChild(0);
1067
1068            boolean allowNull = node.getType() == SAFEDEREF;
1069
1070            return buildTerm(activeType, term, allowNull ? NullHandling.ALLOW : NullHandling.FORBID);
1071        }
1072
1073        private Term buildTerm(Type activeType, Tree term, final NullHandling nullHandling)
1074        {
1075            assertNodeType(term, IDENTIFIER, INVOKE);
1076
1077            final Term simpleTerm = buildTerm(activeType, term);
1078
1079            if (simpleTerm.genericType.isPrimitive())
1080                return simpleTerm;
1081
1082            return simpleTerm.withCallback(new InstructionBuilderCallback()
1083            {
1084                public void doBuild(InstructionBuilder builder)
1085                {
1086                    simpleTerm.callback.doBuild(builder);
1087
1088                    builder.dupe().when(Condition.NULL, new InstructionBuilderCallback()
1089                    {
1090                        public void doBuild(InstructionBuilder builder)
1091                        {
1092                            switch (nullHandling)
1093                            {
1094                                // It is necessary to load a null onto the stack (even if there's already one
1095                                // there) because of the verifier. It sees the return when the stack contains an
1096                                // intermediate value (along the navigation chain) and thinks the method is
1097                                // returning a value of the wrong type.
1098
1099                                case ALLOW:
1100                                    builder.loadNull().returnResult();
1101
1102                                case FORBID:
1103
1104                                    builder.loadConstant(simpleTerm.description);
1105                                    builder.loadConstant(expression);
1106                                    builder.loadArgument(0);
1107
1108                                    builder.invokeStatic(PropertyConduitSourceImpl.class, NullPointerException.class,
1109                                            "nullTerm", String.class, String.class, Object.class);
1110                                    builder.throwException();
1111
1112                                    break;
1113
1114                            }
1115                        }
1116                    });
1117                }
1118            });
1119        }
1120
1121        private void assertNodeType(Tree node, int... expected)
1122        {
1123            int type = node.getType();
1124
1125            for (int e : expected)
1126            {
1127                if (type == e)
1128                    return;
1129            }
1130
1131            throw unexpectedNodeType(node, expected);
1132        }
1133
1134        private RuntimeException unexpectedNodeType(Tree node, int... expected)
1135        {
1136            List<String> tokenNames = CollectionFactory.newList();
1137
1138            for (int i = 0; i < expected.length; i++)
1139                tokenNames.add(PropertyExpressionParser.tokenNames[expected[i]]);
1140
1141            String message = String.format("Node %s was type %s, but was expected to be (one of) %s.",
1142                    node.toStringTree(), PropertyExpressionParser.tokenNames[node.getType()],
1143                    InternalCommonsUtils.joinSorted(tokenNames));
1144
1145            return new RuntimeException(message);
1146        }
1147
1148        private Term buildTerm(Type activeType, Tree termNode)
1149        {
1150            switch (termNode.getType())
1151            {
1152                case INVOKE:
1153
1154                    return buildInvokeTerm(activeType, termNode);
1155
1156                case IDENTIFIER:
1157
1158                    return buildPropertyAccessTerm(activeType, termNode);
1159
1160                default:
1161                    throw unexpectedNodeType(termNode, INVOKE, IDENTIFIER);
1162            }
1163        }
1164
1165        private Term buildPropertyAccessTerm(Type activeType, Tree termNode)
1166        {
1167            String propertyName = termNode.getText();
1168
1169            PropertyAdapter adapter = findPropertyAdapter(activeType, propertyName);
1170
1171            // Prefer the accessor over the field
1172
1173            if (adapter.getReadMethod() != null)
1174            {
1175                return buildGetterMethodAccessTerm(activeType, propertyName,
1176                        adapter.getReadMethod());
1177            }
1178
1179            if (adapter.getField() != null)
1180            {
1181                return buildPublicFieldAccessTerm(activeType, propertyName,
1182                        adapter.getField());
1183            }
1184
1185            throw new RuntimeException(String.format(
1186                    "Property '%s' of class %s is not readable (it has no read accessor method).", adapter.getName(),
1187                    adapter.getBeanType().getName()));
1188        }
1189
1190        public PropertyAdapter findPropertyAdapter(Type activeType, String propertyName)
1191        {
1192            Class activeClass = GenericsUtils.asClass(activeType);
1193
1194            ClassPropertyAdapter classAdapter = access.getAdapter(activeClass);
1195            PropertyAdapter adapter = classAdapter.getPropertyAdapter(propertyName);
1196
1197            if (adapter == null)
1198            {
1199                final List<String> names = classAdapter.getPropertyNames();
1200                final String className = activeClass.getName();
1201                throw new UnknownValueException(String.format(
1202                        "Class %s does not contain a property (or public field) named '%s'.", className, propertyName),
1203                        new AvailableValues("Properties (and public fields)", names));
1204            }
1205            return adapter;
1206        }
1207
1208        private Term buildGetterMethodAccessTerm(final Type activeType, String propertyName, final Method readMethod)
1209        {
1210            Type returnType = GenericsUtils.extractActualType(activeType, readMethod);
1211
1212            return new Term(returnType, propertyName, new InstructionBuilderCallback()
1213            {
1214                public void doBuild(InstructionBuilder builder)
1215                {
1216                    invokeMethod(builder, readMethod, null, 0);
1217
1218                    Type genericType = GenericsUtils.extractActualType(activeType, readMethod);
1219
1220                    castToGenericType(builder, readMethod.getReturnType(), genericType);
1221                }
1222            });
1223        }
1224
1225        private Term buildPublicFieldAccessTerm(Type activeType, String propertyName, final Field field)
1226        {
1227            final Type fieldType = GenericsUtils.extractActualType(activeType, field);
1228
1229            return new Term(fieldType, propertyName, new InstructionBuilderCallback()
1230            {
1231                public void doBuild(InstructionBuilder builder)
1232                {
1233                    Class rawFieldType = field.getType();
1234
1235                    String rawTypeName = PlasticUtils.toTypeName(rawFieldType);
1236                    String containingClassName = field.getDeclaringClass().getName();
1237                    String fieldName = field.getName();
1238
1239                    if (isStatic(field))
1240                    {
1241                        // We've gone to the trouble of loading the root object, or navigated to some other object,
1242                        // but we don't need or want the instance, since it's a static field we're accessing.
1243                        // Ideally, we would optimize this, and only generate and invoke the getRoot() and nav() methods as needed, but
1244                        // access to public fields is relatively rare, and the cost is just the unused bytecode.
1245
1246                        builder.pop();
1247
1248                        builder.getStaticField(containingClassName, fieldName, rawTypeName);
1249
1250                    } else
1251                    {
1252                        builder.getField(containingClassName, fieldName, rawTypeName);
1253                    }
1254
1255                    castToGenericType(builder, rawFieldType, fieldType);
1256                }
1257
1258            });
1259        }
1260
1261        /**
1262         * Casts the results of a field read or method invocation based on generic information.
1263         *
1264         * @param builder
1265         *         used to add instructions
1266         * @param rawType
1267         *         the simple type (often Object) of the field (or method return type)
1268         * @param genericType
1269         *         the generic Type, from which parameterizations can be determined
1270         */
1271        private void castToGenericType(InstructionBuilder builder, Class rawType, final Type genericType)
1272        {
1273            if (!genericType.equals(rawType))
1274            {
1275                Class castType = GenericsUtils.asClass(genericType);
1276                builder.checkcast(castType);
1277            }
1278        }
1279
1280        private Term buildInvokeTerm(final Type activeType, final Tree invokeNode)
1281        {
1282            String methodName = invokeNode.getChild(0).getText();
1283
1284            int parameterCount = invokeNode.getChildCount() - 1;
1285
1286            Class activeClass = GenericsUtils.asClass(activeType);
1287
1288            final Method method = findMethod(activeClass, methodName, parameterCount);
1289
1290            if (method.getReturnType().equals(void.class))
1291                throw new RuntimeException(String.format("Method %s.%s() returns void.", activeClass.getName(),
1292                        methodName));
1293
1294            Type returnType = GenericsUtils.extractActualType(activeType, method);
1295
1296            return new Term(returnType, toUniqueId(method), InternalCommonsUtils.toAnnotationProvider(method), new InstructionBuilderCallback()
1297            {
1298                public void doBuild(InstructionBuilder builder)
1299                {
1300                    invokeMethod(builder, method, invokeNode, 1);
1301
1302                    Type genericType = GenericsUtils.extractActualType(activeType, method);
1303
1304                    castToGenericType(builder, method.getReturnType(), genericType);
1305                }
1306            }
1307            );
1308        }
1309
1310        private Method findMethod(Class activeType, String methodName, int parameterCount)
1311        {
1312            Class searchType = activeType;
1313
1314            while (true)
1315            {
1316
1317                for (Method method : searchType.getMethods())
1318                {
1319                    if (method.getParameterTypes().length == parameterCount
1320                            && method.getName().equalsIgnoreCase(methodName))
1321                        return method;
1322                }
1323
1324                // TAP5-330
1325                if (searchType != Object.class)
1326                {
1327                    searchType = Object.class;
1328                } else
1329                {
1330                    throw new RuntimeException(String.format("Class %s does not contain a public method named '%s()'.",
1331                            activeType.getName(), methodName));
1332                }
1333            }
1334        }
1335
1336        public void boxIfPrimitive(InstructionBuilder builder, Type termType)
1337        {
1338            boxIfPrimitive(builder, GenericsUtils.asClass(termType));
1339        }
1340
1341        public void boxIfPrimitive(InstructionBuilder builder, Class termType)
1342        {
1343            if (termType.isPrimitive())
1344                builder.boxPrimitive(termType.getName());
1345        }
1346
1347        public Class implementNotExpression(InstructionBuilder builder, final Tree notNode)
1348        {
1349            Type expressionType = implementSubexpression(builder, null, notNode.getChild(0));
1350
1351            boxIfPrimitive(builder, expressionType);
1352
1353            // Now invoke the delegate invert() method
1354
1355            builder.loadThis().getField(getDelegateField());
1356
1357            builder.swap().invoke(DelegateMethods.INVERT);
1358
1359            return boolean.class;
1360        }
1361
1362        /**
1363         * Defer creation of the delegate field unless actually needed.
1364         */
1365        private PlasticField getDelegateField()
1366        {
1367            if (delegateField == null)
1368                delegateField = plasticClass.introduceField(PropertyConduitDelegate.class, "delegate").inject(
1369                        sharedDelegate);
1370
1371            return delegateField;
1372        }
1373    }
1374
1375    public PropertyConduitSourceImpl(PropertyAccess access, @ComponentLayer
1376    PlasticProxyFactory proxyFactory, TypeCoercer typeCoercer, StringInterner interner)
1377    {
1378        this.access = access;
1379        this.proxyFactory = proxyFactory;
1380        this.typeCoercer = typeCoercer;
1381        this.interner = interner;
1382
1383        literalTrue = createLiteralConduit(Boolean.class, true);
1384        literalFalse = createLiteralConduit(Boolean.class, false);
1385        literalNull = createLiteralConduit(Void.class, null);
1386
1387        sharedDelegate = new PropertyConduitDelegate(typeCoercer);
1388    }
1389
1390    @PostInjection
1391    public void listenForInvalidations(@ComponentClasses InvalidationEventHub hub)
1392    {
1393        hub.addInvalidationCallback(this::listen);
1394    }
1395    
1396    private List<String> listen(List<String> resources)
1397    {
1398        
1399        if (resources.isEmpty())
1400        {
1401            cache.clear();
1402        }
1403        else
1404        {
1405        
1406            final Iterator<Entry<MultiKey, PropertyConduit>> iterator = cache.entrySet().iterator();
1407            
1408            while (iterator.hasNext())
1409            {
1410                
1411                final Entry<MultiKey, PropertyConduit> entry = iterator.next();
1412                
1413                for (String resource : resources) {
1414                    @SuppressWarnings("rawtypes")
1415                    final Class clasz = (Class) entry.getKey().getValues()[0];
1416                    if (clasz.getName().equals(resource))
1417                    {
1418                        iterator.remove();
1419                    }   
1420                }
1421                
1422            }
1423            
1424        }
1425        
1426        return Collections.emptyList();
1427        
1428    }
1429
1430    public PropertyConduit create(Class rootClass, String expression)
1431    {
1432        assert rootClass != null;
1433        assert InternalCommonsUtils.isNonBlank(expression);
1434
1435        MultiKey key = new MultiKey(rootClass, expression);
1436
1437        PropertyConduit result = cache.get(key);
1438
1439        if (result == null)
1440        {
1441            result = build(rootClass, expression);
1442            cache.put(key, result);
1443        }
1444
1445        return result;
1446    }
1447
1448    /**
1449     * Builds a subclass of {@link PropertyConduitDelegate} that implements the
1450     * get() and set() methods and overrides the
1451     * constructor. In a worst-case race condition, we may build two (or more)
1452     * conduits for the same
1453     * rootClass/expression, and it will get sorted out when the conduit is
1454     * stored into the cache.
1455     *
1456     * @param rootClass
1457     *         class of root object for expression evaluation
1458     * @param expression
1459     *         expression to be evaluated
1460     * @return the conduit
1461     */
1462    private PropertyConduit build(final Class rootClass, String expression)
1463    {
1464        Tree tree = parse(expression);
1465
1466        try
1467        {
1468            switch (tree.getType())
1469            {
1470                case TRUE:
1471
1472                    return literalTrue;
1473
1474                case FALSE:
1475
1476                    return literalFalse;
1477
1478                case NULL:
1479
1480                    return literalNull;
1481
1482                case INTEGER:
1483
1484                    // Leading '+' may screw this up.
1485                    // TODO: Singleton instance for "0", maybe "1"?
1486
1487                    return createLiteralConduit(Long.class, Long.valueOf(tree.getText()));
1488
1489                case DECIMAL:
1490
1491                    // Leading '+' may screw this up.
1492                    // TODO: Singleton instance for "0.0"?
1493
1494                    return createLiteralConduit(Double.class, Double.valueOf(tree.getText()));
1495
1496                case STRING:
1497
1498                    return createLiteralConduit(String.class, tree.getText());
1499
1500                case RANGEOP:
1501
1502                    Tree fromNode = tree.getChild(0);
1503                    Tree toNode = tree.getChild(1);
1504
1505                    // If the range is defined as integers (not properties, etc.)
1506                    // then it is possible to calculate the value here, once, and not
1507                    // build a new class.
1508
1509                    if (fromNode.getType() != INTEGER || toNode.getType() != INTEGER)
1510                        break;
1511
1512                    int from = Integer.parseInt(fromNode.getText());
1513                    int to = Integer.parseInt(toNode.getText());
1514
1515                    IntegerRange ir = new IntegerRange(from, to);
1516
1517                    return createLiteralConduit(IntegerRange.class, ir);
1518
1519                case THIS:
1520
1521                    return createLiteralThisPropertyConduit(rootClass);
1522
1523                default:
1524                    break;
1525            }
1526
1527            return proxyFactory.getProxyFactory(rootClass.getName()).createProxy(InternalPropertyConduit.class,
1528                    new PropertyConduitBuilder(rootClass, expression, tree)).newInstance();
1529        } catch (Exception ex)
1530        {
1531            throw new PropertyExpressionException(String.format("Exception generating conduit for expression '%s': %s",
1532                    expression, ExceptionUtils.toMessage(ex)), expression, ex);
1533        }
1534    }
1535
1536    private PropertyConduit createLiteralThisPropertyConduit(final Class rootClass)
1537    {
1538        return new PropertyConduit()
1539        {
1540            public Object get(Object instance)
1541            {
1542                return instance;
1543            }
1544
1545            public void set(Object instance, Object value)
1546            {
1547                throw new RuntimeException("Literal values are not updateable.");
1548            }
1549
1550            public Class getPropertyType()
1551            {
1552                return rootClass;
1553            }
1554            
1555            public Type getPropertyGenericType()
1556            {
1557                return rootClass;
1558            }
1559
1560            public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
1561            {
1562                return invariantAnnotationProvider.getAnnotation(annotationClass);
1563            }
1564        };
1565    }
1566
1567    private <T> PropertyConduit createLiteralConduit(Class<T> type, T value)
1568    {
1569        return new LiteralPropertyConduit(typeCoercer, type, invariantAnnotationProvider, interner.format(
1570                "LiteralPropertyConduit[%s]", value), value);
1571    }
1572
1573    private Tree parse(String expression)
1574    {
1575        InputStream is = new ByteArrayInputStream(expression.getBytes());
1576
1577        ANTLRInputStream ais;
1578
1579        try
1580        {
1581            ais = new ANTLRInputStream(is);
1582        } catch (IOException ex)
1583        {
1584            throw new RuntimeException(ex);
1585        }
1586
1587        PropertyExpressionLexer lexer = new PropertyExpressionLexer(ais);
1588
1589        CommonTokenStream tokens = new CommonTokenStream(lexer);
1590
1591        PropertyExpressionParser parser = new PropertyExpressionParser(tokens);
1592
1593        try
1594        {
1595            return (Tree) parser.start().getTree();
1596        } catch (Exception ex)
1597        {
1598            throw new RuntimeException(String.format("Error parsing property expression '%s': %s.", expression,
1599                    ex.getMessage()), ex);
1600        }
1601    }
1602
1603    /**
1604     * May be invoked from fabricated PropertyConduit instances.
1605     */
1606    @SuppressWarnings("unused")
1607    public static NullPointerException nullTerm(String term, String expression, Object root)
1608    {
1609        String message = String.format("Property '%s' (within property expression '%s', of %s) is null.", term,
1610                expression, root);
1611
1612        return new NullPointerException(message);
1613    }
1614
1615    private static String toUniqueId(Method method)
1616    {
1617        StringBuilder builder = new StringBuilder(method.getName()).append('(');
1618        String sep = "";
1619
1620        for (Class parameterType : method.getParameterTypes())
1621        {
1622            builder.append(sep);
1623            builder.append(PlasticUtils.toTypeName(parameterType));
1624
1625            sep = ",";
1626        }
1627
1628        return builder.append(')').toString();
1629    }
1630    
1631}