import groovy.lang.MetaProperty; //导入依赖的package包/类
public Map<String, ?> getProperties() {
    if (!includeProperties) {
        return Collections.emptyMap();
    }

    Map<String, Object> properties = new HashMap<String, Object>();
    List<MetaProperty> classProperties = getMetaClass().getProperties();
    for (MetaProperty metaProperty : classProperties) {
        if (metaProperty.getName().equals("properties")) {
            properties.put("properties", properties);
            continue;
        }
        if (metaProperty instanceof MetaBeanProperty) {
            MetaBeanProperty beanProperty = (MetaBeanProperty) metaProperty;
            if (beanProperty.getGetter() == null) {
                continue;
            }
        }
        properties.put(metaProperty.getName(), metaProperty.getProperty(bean));
    }
    getOpaqueProperties(properties);
    return properties;
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private CallSite createPojoMetaClassGetPropertySite(Object receiver) {
    final MetaClass metaClass = InvokerHelper.getMetaClass(receiver);

    CallSite site;
    if (metaClass.getClass() != MetaClassImpl.class || GroovyCategorySupport.hasCategoryInCurrentThread()) {
        site = new PojoMetaClassGetPropertySite(this);
    } else {
        final MetaProperty effective = ((MetaClassImpl) metaClass).getEffectiveGetMetaProperty(receiver.getClass(), receiver, name, false);
        if (effective != null) {
            if (effective instanceof CachedField)
                site = new GetEffectivePojoFieldSite(this, (MetaClassImpl) metaClass, (CachedField) effective);
            else
                site = new GetEffectivePojoPropertySite(this, (MetaClassImpl) metaClass, effective);
        } else {
            site = new PojoMetaClassGetPropertySite(this);
        }
    }

    array.array[index] = site;
    return site;
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private CallSite createPogoMetaClassGetPropertySite(GroovyObject receiver) {
    MetaClass metaClass = receiver.getMetaClass();

    CallSite site;
    if (metaClass.getClass() != MetaClassImpl.class || GroovyCategorySupport.hasCategoryInCurrentThread()) {
        site = new PogoMetaClassGetPropertySite(this, metaClass);
    } else {
        final MetaProperty effective = ((MetaClassImpl) metaClass).getEffectiveGetMetaProperty(this.array.owner, receiver, name, false);
        if (effective != null) {
            if (effective instanceof CachedField)
                site = new GetEffectivePogoFieldSite(this, metaClass, (CachedField) effective);
            else
                site = new GetEffectivePogoPropertySite(this, metaClass, effective);
        } else {
            site = new PogoMetaClassGetPropertySite(this, metaClass);
        }
    }

    array.array[index] = site;
    return site;
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
/**
 * Returns a string detailing possible solutions to a missing field or property
 * if no good solutions can be found a empty string is returned.
 *
 * @param fieldName the missing field
 * @param type the class on which the field is sought
 * @return a string with probable solutions to the exception
 */
public static String getPropertySuggestionString(String fieldName, Class type){
    ClassInfo ci = ClassInfo.getClassInfo(type);
    List<MetaProperty>  fi = ci.getMetaClass().getProperties();
    List<RankableField> rf = new ArrayList<RankableField>(fi.size());
    StringBuilder sb = new StringBuilder();
    sb.append("\nPossible solutions: ");
    
    for(MetaProperty mp : fi) rf.add(new RankableField(fieldName, mp));
    Collections.sort(rf);

    int i = 0;
    for (RankableField f : rf) {
        if (i > MAX_RECOMENDATIONS) break;
        if (f.score > MAX_FIELD_SCORE) break;
        if(i > 0) sb.append(", ");
        sb.append(f.f.getName());
        i++;
    }
    return i > 0? sb.toString(): "";
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
public void setChild(FactoryBuilderSupport builder, Object parent, Object child) {
    if (child == null) return;

    ObjectGraphBuilder ogbuilder = (ObjectGraphBuilder) builder;
    if (parent != null) {
        Map context = ogbuilder.getContext();
        Map parentContext = ogbuilder.getParentContext();

        String parentName = null;
        String childName = (String) context.get(NODE_NAME);
        if (parentContext != null) {
            parentName = (String) parentContext.get(NODE_NAME);
        }

        String propertyName = ogbuilder.relationNameResolver.resolveParentRelationName(
                parentName, parent, childName, child);
        MetaProperty metaProperty = InvokerHelper.getMetaClass(child)
                .hasProperty(child, propertyName);
        if (metaProperty != null) {
            metaProperty.setProperty(child, parent);
        }
    }
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private Map resolveConstrainedProperties(Object object, GrailsDomainClass dc) {
	Map constrainedProperties = null;
	if (dc != null) {
		constrainedProperties = dc.getConstrainedProperties();
	} else {
		// is this dead code? , didn't remove in case it's used somewhere
		MetaClass mc = GroovySystem.getMetaClassRegistry().getMetaClass(object.getClass());
		MetaProperty metaProp = mc.getMetaProperty(CONSTRAINTS_PROPERTY);
		if (metaProp != null) {
			Object constrainedPropsObj = getMetaPropertyValue(metaProp, object);
			if (constrainedPropsObj instanceof Map) {
				constrainedProperties = (Map) constrainedPropsObj;
			}
		}
	}
	return constrainedProperties;
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
@Nullable
protected MetaProperty lookupProperty(MetaClass metaClass, String name) {
    if (metaClass instanceof MetaClassImpl) {
        // MetaClass.getMetaProperty(name) is very expensive when the property is not known. Instead, reach into the meta class to call a much more efficient lookup method
        try {
            return (MetaProperty) META_PROP_METHOD.invoke(metaClass, name, false);
        } catch (Throwable e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    // Some other meta-class implementation - fall back to the public API
    return metaClass.getMetaProperty(name);
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private static MetaMethod createSetter(final MetaProperty property, final MixinInMetaClass mixinInMetaClass) {
  return new MetaMethod() {
      final String name = getSetterName(property.getName());
      {
          setParametersTypes (new CachedClass [] {ReflectionCache.getCachedClass(property.getType())} );
      }

      public int getModifiers() {
          return Modifier.PUBLIC;
      }

      public String getName() {
          return name;
      }

      public Class getReturnType() {
          return property.getType();
      }

      public CachedClass getDeclaringClass() {
          return mixinInMetaClass.getInstanceClass();
      }

      public Object invoke(Object object, Object[] arguments) {
          property.setProperty(mixinInMetaClass.getMixinInstance(object), arguments[0]);
          return null;
      }
  };
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private static MetaMethod createGetter(final MetaProperty property, final MixinInMetaClass mixinInMetaClass) {
    return new MetaMethod() {
        final String name = getGetterName(property.getName(), property.getType());
        {
            setParametersTypes (CachedClass.EMPTY_ARRAY);
        }

        public int getModifiers() {
            return Modifier.PUBLIC;
        }

        public String getName() {
            return name;
        }

        public Class getReturnType() {
            return property.getType();
        }

        public CachedClass getDeclaringClass() {
            return mixinInMetaClass.getInstanceClass();
        }

        public Object invoke(Object object, Object[] arguments) {
            return property.getProperty(mixinInMetaClass.getMixinInstance(object));
        }
    };
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
/**
 * Handles the common English regular plurals with the following rules.
 * <ul>
 * <li>If childName ends in {consonant}y, replace 'y' with "ies". For example, allergy to allergies.</li>
 * <li>Otherwise, append 's'. For example, monkey to monkeys; employee to employees.</li>
 * </ul>
 * If the property does not exist then it will return childName unchanged.
 *
 * @see <a href="http://en.wikipedia.org/wiki/English_plural">English_plural</a>
 */
public String resolveChildRelationName(String parentName, Object parent, String childName,
                                       Object child) {
    boolean matchesIESRule = PLURAL_IES_PATTERN.matcher(childName).matches();
    String childNamePlural = matchesIESRule ? childName.substring(0, childName.length() - 1) + "ies" : childName + "s";

    MetaProperty metaProperty = InvokerHelper.getMetaClass(parent)
            .hasProperty(parent, childNamePlural);

    return metaProperty != null ? childNamePlural : childName;
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private void resolveLazyReferences() {
    if (!lazyReferencesAllowed) return;
    for (NodeReference ref : lazyReferences) {
        if (ref.parent == null) continue;

        Object child = null;
        try {
            child = getProperty(ref.refId);
        } catch (MissingPropertyException mpe) {
            // ignore
        }
        if (child == null) {
            throw new IllegalArgumentException("There is no valid node for reference "
                    + ref.parentName + "." + ref.childName + "=" + ref.refId);
        }

        // set child first
        childPropertySetter.setChild(ref.parent, child, ref.parentName,
                relationNameResolver.resolveChildRelationName(ref.parentName,
                        ref.parent, ref.childName, child));

        // set parent afterwards
        String propertyName = relationNameResolver.resolveParentRelationName(ref.parentName,
                ref.parent, ref.childName, child);
        MetaProperty metaProperty = InvokerHelper.getMetaClass(child)
                .hasProperty(child, propertyName);
        if (metaProperty != null) {
            metaProperty.setProperty(child, ref.parent);
        }
    }
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
public void testInspectUninspectableProperty() {
    Object dummyInstance = new Object();
    Inspector inspector = getTestableInspector(dummyInstance);
    Class[] paramTypes = {Object.class, MetaProperty.class};
    Object[] params = {null, null};
    Mock mock = mock(PropertyValue.class, paramTypes, params);
    mock.expects(once()).method("getType");
    mock.expects(once()).method("getName");
    mock.expects(once()).method("getValue").will(throwException(new RuntimeException()));
    PropertyValue propertyValue = (PropertyValue) mock.proxy();
    String[] result = inspector.fieldInfo(propertyValue);
    assertEquals(Inspector.NOT_APPLICABLE, result[Inspector.MEMBER_VALUE_IDX]);
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
/**
 * Hack because of bug in ThreadManagedMetaBeanProperty, http://jira.codehaus.org/browse/GROOVY-3723 , fixed since 1.6.5
 *
 * @param metaProperty
 * @param delegate
 * @return
 */
private Object getMetaPropertyValue(MetaProperty metaProperty, Object delegate) {
	if (metaProperty instanceof ThreadManagedMetaBeanProperty) {
		return ((ThreadManagedMetaBeanProperty) metaProperty).getGetter().invoke(delegate, MetaClassHelper.EMPTY_ARRAY);
	}

	return metaProperty.getProperty(delegate);
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
@Test(groups = { TestGroups.UNIT })
public void hasFieldTest() {
    class TestClass {
        @SuppressWarnings("unused")
        public Object a = new Object();
    }

    Assert.assertTrue(DefaultGroovyMethods.hasProperty(TestClass.class, "a") == null);
    Assert.assertTrue(ClassUtil.hasField(TestClass.class, "a") instanceof MetaProperty);

    Assert.assertFalse(ClassUtil.hasField(TestClass.class, "b") instanceof MetaProperty);
    Assert.assertTrue(ClassUtil.hasField(TestClass.class, "b") == null);
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private void initGroovyCommands(final ScriptEngine scriptEngine, final ScriptContext scriptContext) {
	Commands commands = new Commands(scriptContext);

	for (MetaProperty mp : commands.getMetaClass().getProperties()) {
		String propertyType = mp.getType().getCanonicalName();
		String propertyName = mp.getName();

		if (propertyType.equals(groovy.lang.Closure.class.getCanonicalName())) {
			scriptEngine.put(propertyName, commands.getProperty(propertyName));
		}
	}
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
public void setProperty(final String name, Object value, SetPropertyResult result) {
    if (!includeProperties) {
        return;
    }

    MetaClass metaClass = getMetaClass();
    MetaProperty property = lookupProperty(metaClass, name);
    if (property != null) {
        if (property instanceof MultipleSetterProperty) {
            // Invoke the setter method, to pick up type coercion
            String setterName = MetaProperty.getSetterName(property.getName());
            InvokeMethodResult setterResult = new InvokeMethodResult();
            invokeMethod(setterName, setterResult, value);
            if (setterResult.isFound()) {
                result.found();
                return;
            }
        } else {
            if (property instanceof MetaBeanProperty) {
                MetaBeanProperty metaBeanProperty = (MetaBeanProperty) property;
                if (metaBeanProperty.getSetter() == null) {
                    if (metaBeanProperty.getField() == null) {
                        throw setReadOnlyProperty(name);
                    }
                    value = propertySetTransformer.transformValue(metaBeanProperty.getField().getType(), value);
                    metaBeanProperty.getField().setProperty(bean, value);
                } else {
                    // Coerce the value to the type accepted by the property setter and invoke the setter directly
                    Class setterType = metaBeanProperty.getSetter().getParameterTypes()[0].getTheClass();
                    value = propertySetTransformer.transformValue(setterType, value);
                    value = DefaultTypeTransformation.castToType(value, setterType);
                    metaBeanProperty.getSetter().invoke(bean, new Object[]{value});
                }
            } else {
                // Coerce the value to the property type, if known
                value = propertySetTransformer.transformValue(property.getType(), value);
                property.setProperty(bean, value);
            }
            result.found();
            return;
        }
    }

    if (!implementsMissing) {
        return;
    }

    try {
        setOpaqueProperty(metaClass, name, value);
        result.found();
    } catch (MissingPropertyException e) {
        if (!name.equals(e.getProperty())) {
            throw e;
        }
    }
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
private Expression transformBinaryExpression(final BinaryExpression exp) {
    Expression trn = super.transform(exp);
    if (trn instanceof BinaryExpression) {
        BinaryExpression bin = (BinaryExpression) trn;
        Expression leftExpression = bin.getLeftExpression();
        if (bin.getOperation().getType() == Types.EQUAL && leftExpression instanceof PropertyExpression) {
            ClassNode traitReceiver = null;
            PropertyExpression leftPropertyExpression = (PropertyExpression) leftExpression;
            if (isTraitSuperPropertyExpression(leftPropertyExpression.getObjectExpression())) {
                PropertyExpression pexp = (PropertyExpression) leftPropertyExpression.getObjectExpression();
                traitReceiver = pexp.getObjectExpression().getType();
            }
            if (traitReceiver!=null) {
                // A.super.foo = ...
                TraitHelpersTuple helpers = Traits.findHelpers(traitReceiver);
                ClassNode helper = helpers.getHelper();
                String setterName = MetaProperty.getSetterName(leftPropertyExpression.getPropertyAsString());
                List<MethodNode> methods = helper.getMethods(setterName);
                for (MethodNode method : methods) {
                    Parameter[] parameters = method.getParameters();
                    if (parameters.length==2 && parameters[0].getType().equals(traitReceiver)) {
                        ArgumentListExpression args = new ArgumentListExpression(
                                new VariableExpression("this"),
                                transform(exp.getRightExpression())
                        );
                        MethodCallExpression setterCall = new MethodCallExpression(
                                new ClassExpression(helper),
                                setterName,
                                args
                        );
                        setterCall.setMethodTarget(method);
                        setterCall.setImplicitThis(false);
                        return setterCall;
                    }
                }
                return bin;
            }
        }
    }
    return trn;
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
public GetEffectivePojoPropertySite(CallSite site, MetaClassImpl metaClass, MetaProperty effective) {
    super(site);
    this.metaClass = metaClass;
    this.effective = effective;
    version = metaClass.getVersion();
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
public GetEffectivePogoPropertySite(CallSite site, MetaClass metaClass, MetaProperty effective) {
    super(site);
    this.metaClass = metaClass;
    this.effective = effective;
}
 

import groovy.lang.MetaProperty; //导入依赖的package包/类
public RankableField(String name, MetaProperty mp) {
    this.f = mp;
    this.score = delDistance(name,mp.getName());
}