Java JvmGenericType.getMembers方法代码示例

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void test_staticNestedTypes_constructor() {
	String typeName = Bug347739.class.getName();
	JvmGenericType type = (JvmGenericType) getTypeProvider().findTypeByName(typeName);
	List<JvmMember> members = type.getMembers();
	for (JvmMember member : members) {
		if (member instanceof JvmGenericType) {
			if ("StackItem".equals(member.getSimpleName())) {
				JvmGenericType stackItem = (JvmGenericType) member;
				Iterable<JvmConstructor> constructors = stackItem.getDeclaredConstructors();
				for (JvmConstructor constructor : constructors) {
					assertEquals(2, constructor.getParameters().size());
				}
				return;
			}
		}
	}
	fail("could not find inner class");
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testLinkToParameter() {
  try {
    final XExpression expr = this.expression("x", false);
    final Resource resource = expr.eResource();
    resource.eSetDeliver(false);
    EList<EObject> _contents = resource.getContents();
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        EList<JvmFormalParameter> _parameters = it_1.getParameters();
        JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(expr, "x", this.stringType(expr));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        this._jvmTypesBuilder.setBody(it_1, expr);
      };
      JvmOperation _method = this._jvmTypesBuilder.toMethod(expr, "doStuff", this.stringType(expr), _function_1);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members, _method);
    };
    JvmGenericType _class = this._jvmTypesBuilder.toClass(expr, "Foo", _function);
    this._jvmTypesBuilder.<JvmGenericType>operator_add(_contents, _class);
    this._validationTestHelper.assertNoErrors(expr);
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testSimple() {
  try {
    final XExpression expression = this.expression("return s.toUpperCase", false);
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        EList<JvmFormalParameter> _parameters = it_1.getParameters();
        JvmFormalParameter _parameter = this.builder.toParameter(expression, "s", this.references.getTypeForName(String.class, expression));
        this.builder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        this.builder.setBody(it_1, expression);
      };
      JvmOperation _method = this.builder.toMethod(expression, "doStuff", this.references.getTypeForName(String.class, expression), _function_1);
      this.builder.<JvmOperation>operator_add(_members, _method);
    };
    final JvmGenericType clazz = this.builder.toClass(expression, "my.test.Foo", _function);
    final Class<?> compiledClass = this.compile(expression.eResource(), clazz);
    final Object instance = compiledClass.newInstance();
    Assert.assertEquals("FOO", compiledClass.getMethod("doStuff", String.class).invoke(instance, "foo"));
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testCompilationStrategy() {
  try {
    final XExpression expression = this.expression("null", false);
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      JvmField _field = this.builder.toField(expression, "x", this.typeRef(expression, String.class));
      this.builder.<JvmField>operator_add(_members, _field);
      EList<JvmMember> _members_1 = it.getMembers();
      JvmOperation _getter = this.builder.toGetter(expression, "x", this.typeRef(expression, String.class));
      this.builder.<JvmOperation>operator_add(_members_1, _getter);
      EList<JvmMember> _members_2 = it.getMembers();
      JvmOperation _setter = this.builder.toSetter(expression, "x", this.typeRef(expression, String.class));
      this.builder.<JvmOperation>operator_add(_members_2, _setter);
    };
    final JvmGenericType clazz = this.builder.toClass(expression, "my.test.Foo", _function);
    final Class<?> compiled = this.compile(expression.eResource(), clazz);
    final Object inst = compiled.newInstance();
    final Method getter = compiled.getMethod("getX");
    final Method setter = compiled.getMethod("setX", String.class);
    setter.invoke(inst, "FOO");
    Assert.assertEquals("FOO", getter.invoke(inst));
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testBug377925No_Nullpointer() {
  try {
    final XExpression expression = this.expression("[Object o| null]");
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        this.builder.setBody(it_1, expression);
      };
      JvmOperation _method = this.builder.toMethod(expression, "doStuff", this.references.getTypeForName("java.lang.Object", expression), _function_1);
      this.builder.<JvmOperation>operator_add(_members, _method);
    };
    final JvmGenericType clazz = this.builder.toClass(expression, "my.test.Foo", _function);
    this.compile(expression.eResource(), clazz);
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testNestedAnnotationType() {
  try {
    final XExpression expression = this.expression("42");
    final JvmGenericType outerClass = this.builder.toClass(expression, "my.outer.Clazz");
    EList<JvmMember> _members = outerClass.getMembers();
    final Procedure1<JvmAnnotationType> _function = (JvmAnnotationType it) -> {
      EList<JvmMember> _members_1 = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        this.builder.setBody(it_1, expression);
      };
      JvmOperation _method = this.builder.toMethod(expression, "theTruth", this.references.getTypeForName(int.class, expression), _function_1);
      this.builder.<JvmOperation>operator_add(_members_1, _method);
    };
    JvmAnnotationType _annotationType = this.builder.toAnnotationType(expression, "MyAnnotation", _function);
    this.builder.<JvmAnnotationType>operator_add(_members, _annotationType);
    final Class<?> compiled = IterableExtensions.<Class<?>>head(((Iterable<Class<?>>)Conversions.doWrapArray(this.compile(expression.eResource(), outerClass).getDeclaredClasses())));
    Assert.assertEquals("my.outer.Clazz.MyAnnotation", compiled.getCanonicalName());
    Assert.assertEquals(Integer.valueOf(42), IterableExtensions.<Method>head(((Iterable<Method>)Conversions.doWrapArray(compiled.getDeclaredMethods()))).getDefaultValue());
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testBug426073() {
  try {
    final XExpression expression = this.expression("org.eclipse.emf.common.util.URI.createURI(\"dummy\")");
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      final Procedure1<JvmField> _function_1 = (JvmField it_1) -> {
        this.builder.setInitializer(it_1, expression);
      };
      JvmField _field = this.builder.toField(expression, "URI", this.typeRef(expression, URI.class), _function_1);
      this.builder.<JvmField>operator_add(_members, _field);
    };
    final JvmGenericType clazz = this.builder.toClass(expression, "my.test.Foo", _function);
    this.compile(expression.eResource(), clazz);
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
protected void _infer(final Model m, final IJvmDeclaredTypeAcceptor acceptor, final boolean prelinkingPhase) {
  final XBlockExpression e = m.getBlock();
  final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
    EList<JvmMember> _members = it.getMembers();
    final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
      EList<JvmTypeReference> _exceptions = it_1.getExceptions();
      JvmTypeReference _typeRef = this._typeReferenceBuilder.typeRef(Throwable.class);
      this._jvmTypesBuilder.<JvmTypeReference>operator_add(_exceptions, _typeRef);
      this._jvmTypesBuilder.setBody(it_1, e);
    };
    JvmOperation _method = this._jvmTypesBuilder.toMethod(e, "myMethod", this._jvmTypesBuilder.inferredType(), _function_1);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members, _method);
  };
  acceptor.<JvmGenericType>accept(this._jvmTypesBuilder.toClass(e, this.name(e.eResource())), _function);
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
protected void assertMembers(String typeName, Set<String> memberNames) {
	JvmGenericType type = (JvmGenericType) getTypeProvider().findTypeByName(typeName);
	assertEquals(memberNames.size(), type.getMembers().size());
	for (org.eclipse.xtext.common.types.JvmMember member : type.getMembers()) {
		assertTrue(member.getIdentifier(), member instanceof JvmOperation);
		JvmOperation op = (JvmOperation) member;
		assertTrue(op.getSimpleName(), memberNames.remove(op.getSimpleName()));
	}
	assertTrue(memberNames.isEmpty());
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Override
public void infer(final EObject e, final IJvmDeclaredTypeAcceptor acceptor, final boolean prelinkingPhase) {
  final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
    EList<JvmMember> _members = it.getMembers();
    final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
      EList<JvmFormalParameter> _parameters = it_1.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(e, "s", this.references.getTypeForName(String.class, e));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      this._jvmTypesBuilder.setBody(it_1, ((XExpression) e));
    };
    JvmOperation _method = this._jvmTypesBuilder.toMethod(e, "doStuff", this.references.getTypeForName(String.class, e), _function_1);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members, _method);
  };
  acceptor.<JvmGenericType>accept(this._jvmTypesBuilder.toClass(((XExpression) e), "Test"), _function);
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testLinkToParameter_1() {
  try {
    XExpression _expression = this.expression("x", false);
    final XFeatureCall expr = ((XFeatureCall) _expression);
    final Resource resource = expr.eResource();
    resource.eSetDeliver(false);
    EList<EObject> _contents = resource.getContents();
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      JvmField _field = this._jvmTypesBuilder.toField(expr, "x", this.stringType(expr));
      this._jvmTypesBuilder.<JvmField>operator_add(_members, _field);
      EList<JvmMember> _members_1 = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        EList<JvmFormalParameter> _parameters = it_1.getParameters();
        JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(expr, "x", this.stringType(expr));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        this._jvmTypesBuilder.setBody(it_1, expr);
      };
      JvmOperation _method = this._jvmTypesBuilder.toMethod(expr, "doStuff", this.stringType(expr), _function_1);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_1, _method);
    };
    JvmGenericType _class = this._jvmTypesBuilder.toClass(expr, "Foo", _function);
    this._jvmTypesBuilder.<JvmGenericType>operator_add(_contents, _class);
    this._validationTestHelper.assertNoErrors(expr);
    JvmIdentifiableElement _feature = expr.getFeature();
    Assert.assertTrue((_feature instanceof JvmFormalParameter));
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testLinkToField() {
  try {
    XExpression _expression = this.expression("x", false);
    final XFeatureCall expr = ((XFeatureCall) _expression);
    final Resource resource = expr.eResource();
    resource.eSetDeliver(false);
    EList<EObject> _contents = resource.getContents();
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      JvmField _field = this._jvmTypesBuilder.toField(expr, "x", this.stringType(expr));
      this._jvmTypesBuilder.<JvmField>operator_add(_members, _field);
      EList<JvmMember> _members_1 = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        EList<JvmFormalParameter> _parameters = it_1.getParameters();
        JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(expr, "y", this.stringType(expr));
        this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
        this._jvmTypesBuilder.setBody(it_1, expr);
      };
      JvmOperation _method = this._jvmTypesBuilder.toMethod(expr, "doStuff", this.stringType(expr), _function_1);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_1, _method);
    };
    JvmGenericType _class = this._jvmTypesBuilder.toClass(expr, "Foo", _function);
    this._jvmTypesBuilder.<JvmGenericType>operator_add(_contents, _class);
    this._validationTestHelper.assertNoErrors(expr);
    JvmIdentifiableElement _feature = expr.getFeature();
    Assert.assertTrue((_feature instanceof JvmField));
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testLinkToField_1() {
  try {
    XExpression _expression = this.expression("x", false);
    final XFeatureCall expr = ((XFeatureCall) _expression);
    final Resource resource = expr.eResource();
    resource.eSetDeliver(false);
    EList<EObject> _contents = resource.getContents();
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      JvmField _field = this._jvmTypesBuilder.toField(expr, "x", this.stringType(expr));
      this._jvmTypesBuilder.<JvmField>operator_add(_members, _field);
      EList<JvmMember> _members_1 = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        this._jvmTypesBuilder.setBody(it_1, expr);
      };
      JvmOperation _method = this._jvmTypesBuilder.toMethod(expr, "getX", this.stringType(expr), _function_1);
      this._jvmTypesBuilder.<JvmOperation>operator_add(_members_1, _method);
    };
    JvmGenericType _class = this._jvmTypesBuilder.toClass(expr, "Foo", _function);
    this._jvmTypesBuilder.<JvmGenericType>operator_add(_contents, _class);
    this._validationTestHelper.assertNoErrors(expr);
    JvmIdentifiableElement _feature = expr.getFeature();
    Assert.assertTrue((_feature instanceof JvmField));
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testBug380754() {
  try {
    final XExpression expression = this.expression("null");
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        this.builder.setBody(it_1, expression);
        final JvmAnnotationReference annotation = this.builder.toAnnotation(expression, TestAnnotations.class);
        final JvmAnnotationAnnotationValue annotationAnnotationValue = this.typesFactory.createJvmAnnotationAnnotationValue();
        EList<JvmAnnotationReference> _values = annotationAnnotationValue.getValues();
        JvmAnnotationReference _annotation = this.builder.toAnnotation(expression, TestAnnotation.class);
        this.builder.<JvmAnnotationReference>operator_add(_values, _annotation);
        EList<JvmAnnotationReference> _values_1 = annotationAnnotationValue.getValues();
        JvmAnnotationReference _annotation_1 = this.builder.toAnnotation(expression, TestAnnotation.class);
        this.builder.<JvmAnnotationReference>operator_add(_values_1, _annotation_1);
        EList<JvmAnnotationReference> _values_2 = annotationAnnotationValue.getValues();
        JvmAnnotationReference _annotation_2 = this.builder.toAnnotation(expression, TestAnnotation.class);
        this.builder.<JvmAnnotationReference>operator_add(_values_2, _annotation_2);
        EList<JvmAnnotationValue> _explicitValues = annotation.getExplicitValues();
        this.builder.<JvmAnnotationAnnotationValue>operator_add(_explicitValues, annotationAnnotationValue);
        EList<JvmAnnotationReference> _annotations = it_1.getAnnotations();
        this.builder.<JvmAnnotationReference>operator_add(_annotations, annotation);
      };
      JvmOperation _method = this.builder.toMethod(expression, "doStuff", this.references.getTypeForName("java.lang.Object", expression), _function_1);
      this.builder.<JvmOperation>operator_add(_members, _method);
    };
    final JvmGenericType clazz = this.builder.toClass(expression, "my.test.Foo", _function);
    this.compile(expression.eResource(), clazz);
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.xtext.common.types.JvmGenericType; //导入方法依赖的package包/类
@Test
public void testBug380754_2() {
  try {
    final XExpression expression = this.expression("null");
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      EList<JvmMember> _members = it.getMembers();
      final Procedure1<JvmOperation> _function_1 = (JvmOperation it_1) -> {
        this.builder.setBody(it_1, expression);
        final JvmFormalParameter parameter = this.builder.toParameter(expression, "s", this.references.getTypeForName(String.class, expression));
        EList<JvmFormalParameter> _parameters = it_1.getParameters();
        this.builder.<JvmFormalParameter>operator_add(_parameters, parameter);
        EList<JvmAnnotationReference> _annotations = parameter.getAnnotations();
        JvmAnnotationReference _annotation = this.builder.toAnnotation(expression, TestAnnotation.class);
        this.builder.<JvmAnnotationReference>operator_add(_annotations, _annotation);
        EList<JvmAnnotationReference> _annotations_1 = parameter.getAnnotations();
        JvmAnnotationReference _annotation_1 = this.builder.toAnnotation(expression, TestAnnotation2.class);
        this.builder.<JvmAnnotationReference>operator_add(_annotations_1, _annotation_1);
      };
      JvmOperation _method = this.builder.toMethod(expression, "doStuff", this.references.getTypeForName("java.lang.Object", expression), _function_1);
      this.builder.<JvmOperation>operator_add(_members, _method);
    };
    final JvmGenericType clazz = this.builder.toClass(expression, "my.test.Foo", _function);
    this.compile(expression.eResource(), clazz);
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}